from django.shortcuts import render
from django.http import JsonResponse
from django.db import connection
from django.contrib.auth.hashers import make_password, check_password
from django.views.decorators.csrf import csrf_exempt
import json
import time
import jwt
import datetime
import logging
from .models import College, Student, Grade, SchoolClass, StudentClass
from django.core.exceptions import ObjectDoesNotExist
import random
import os
import requests
from django.conf import settings
from django.views.decorators.http import require_http_methods
from .models import Resource
from django.utils import timezone
from django.core.files.storage import default_storage
from django.http import StreamingHttpResponse
import pymysql
from functools import wraps

# 配置日志
logger = logging.getLogger(__name__)

# JWT密钥 (在实际环境中应该是通过环境变量或配置文件管理的复杂密钥)
JWT_SECRET = "ai_teach_jwt_secret_key_2024"
# Token过期时间（小时）
TOKEN_EXPIRED_HOURS = 24

# Dify API配置
DIFY_API_URL = os.environ.get('DIFY_API_URL', 'http://121.40.242.43/v1')
DIFY_API_KEY = os.environ.get('DIFY_API_KEY', 'app-qwFwyBuH8krGnieeMJDDAI2O')  # 实际应用中应从环境变量读取
DIFY_APP_ID = os.environ.get('DIFY_APP_ID', '')  # 实际应用中应从环境变量读取

# 数据库连接配置
DB_CONFIG = {
    'host': '47.113.186.218',  # 数据库主机地址
    'user': 'root',            # 数据库用户名
    'password': '2025@Bysj',   # 数据库密码
    'db': 'ai_teach',          # 数据库名
    'charset': 'utf8mb4',
    'port': 3306               # 数据库端口
}

def get_db_connection():
    """连接到数据库"""
    try:
        connection = pymysql.connect(**DB_CONFIG)
        return connection
    except Exception as e:
        logger.error(f"连接数据库出错: {e}")
        return None

# Create your views here.

def test_db_connection(request):
    """
    测试数据库连接
    @description 测试数据库连接是否正常
    @created 2024-04-08
    """
    try:
        with connection.cursor() as cursor:
            # 执行简单查询测试连接
            cursor.execute("SELECT 1")
            result = cursor.fetchone()
            
            # 获取数据库中的表列表
            cursor.execute("SHOW TABLES")
            tables = [table[0] for table in cursor.fetchall()]
            
            return JsonResponse({
                'status': 'success',
                'message': '数据库连接成功',
                'database': connection.settings_dict['NAME'],
                'test_query': result[0],
                'tables': tables
            })
    except Exception as e:
        return JsonResponse({
            'status': 'error',
            'message': f'数据库连接失败：{str(e)}'
        }, status=500)


def generate_token(user_id, username, role):
    """
    生成JWT Token
    @param user_id: 用户ID
    @param username: 用户名
    @param role: 用户角色
    @return: JWT Token
    """
    try:
        # 过期时间
        expire_time = datetime.datetime.utcnow() + datetime.timedelta(hours=TOKEN_EXPIRED_HOURS)
        
        # 创建payload
        payload = {
            'user_id': user_id,
            'username': username,
            'role': role,
            'exp': expire_time
        }
        
        # 生成token
        token = jwt.encode(payload, JWT_SECRET, algorithm='HS256')
        
        return token
    except Exception as e:
        logger.error(f"生成token错误: {str(e)}")
        return None


def validate_token(token):
    """
    验证JWT Token
    @param token: JWT Token
    @return: 如果验证成功，返回payload；否则返回None
    """
    try:
        # 解码并验证token
        payload = jwt.decode(token, JWT_SECRET, algorithms=['HS256'])
        return payload
    except jwt.ExpiredSignatureError:
        logger.warning("Token已过期")
        return None
    except (jwt.InvalidTokenError, Exception) as e:
        logger.error(f"Token验证错误: {str(e)}")
        return None


def check_admin_exists():
    """
    检查数据库中是否存在管理员账号
    如果没有，则创建一个默认管理员账号
    """
    try:
        with connection.cursor() as cursor:
            # 查询users表中是否有超级管理员账号
            cursor.execute("SELECT COUNT(*) FROM users WHERE role = 'school_admin'")
            count = cursor.fetchone()[0]
            
            if count == 0:
                # 创建默认超级管理员账号
                # 密码为123456的加密值
                hashed_password = make_password('123456')
                
                # 插入数据
                cursor.execute("""
                    INSERT INTO users (username, password, email, role) 
                    VALUES (%s, %s, %s, %s)
                """, ('2116411044', hashed_password, 'admin@example.com', 'school_admin'))
                
                # 提交事务
                connection.commit()
                logger.info("已创建默认校级管理员账号")
    except Exception as e:
        logger.error(f"检查/创建管理员账号失败: {str(e)}")


@csrf_exempt
def admin_login(request):
    """
    管理员登录接口
    @route POST /api/auth/admin/login/
    @description 处理管理员登录请求，验证身份并返回token
    @created 2024-04-08
    """
    if request.method != 'POST':
        return JsonResponse({
            'status': 'error',
            'message': '仅支持POST请求'
        }, status=405)
    
    try:
        # 确保管理员账号存在
        check_admin_exists()
        
        # 解析请求体中的JSON数据
        data = json.loads(request.body)
        username = data.get('username')
        password = data.get('password')
        
        # 验证请求参数
        if not all([username, password]):
            return JsonResponse({
                'status': 'error',
                'message': '用户名和密码不能为空'
            }, status=400)
        
        # 在数据库中查询用户
        with connection.cursor() as cursor:
            cursor.execute("""
                SELECT user_id, username, password, role 
                FROM users 
                WHERE username = %s AND role IN ('school_admin', 'college_admin', 'class_admin')
            """, (username,))
            
            user = cursor.fetchone()
            
            if not user:
                return JsonResponse({
                    'status': 'error',
                    'message': '用户名或密码错误'
                }, status=401)
            
            user_id, db_username, db_password, role = user
            
            # 验证密码
            if password != db_password:
                return JsonResponse({
                    'status': 'error',
                    'message': '用户名或密码错误'
                }, status=401)
            
            # 生成token
            token = generate_token(user_id, db_username, role)
            
            if not token:
                return JsonResponse({
                    'status': 'error',
                    'message': '生成令牌失败'
                }, status=500)
            
            # 记录登录日志
            login_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            logger.info(f"管理员 {db_username} 登录成功，角色: {role}，时间: {login_time}")
            
            # 返回成功响应
            return JsonResponse({
                'status': 'success',
                'message': '登录成功',
                'data': {
                    'token': token,
                    'user_id': user_id,
                    'username': db_username,
                    'role': role
                }
            })
            
    except Exception as e:
        logger.error(f"登录处理失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'服务器内部错误: {str(e)}'
        }, status=500)


@csrf_exempt
def admin_info(request):
    """
    获取管理员信息接口
    @route GET /api/auth/admin/info/
    @description 获取当前登录管理员的信息
    @created 2024-04-08
    """
    if request.method != 'GET':
        return JsonResponse({
            'status': 'error',
            'message': '仅支持GET请求'
        }, status=405)
    
    try:
        # 从请求头获取token
        auth_header = request.META.get('HTTP_AUTHORIZATION', '')
        
        if not auth_header.startswith('Bearer '):
            return JsonResponse({
                'status': 'error',
                'message': '未提供有效的令牌'
            }, status=401)
        
        token = auth_header.split(' ')[1]
        
        # 验证token
        payload = validate_token(token)
        
        if not payload:
            return JsonResponse({
                'status': 'error',
                'message': '令牌无效或已过期'
            }, status=401)
        
        # 检查是否为管理员角色
        if payload.get('role') not in ['school_admin', 'college_admin', 'class_admin']:
            return JsonResponse({
                'status': 'error',
                'message': '非管理员用户无权限'
            }, status=403)
        
        # 从数据库获取最新的用户信息
        with connection.cursor() as cursor:
            cursor.execute("""
                SELECT user_id, username, email, role
                FROM users
                WHERE user_id = %s
            """, (payload.get('user_id'),))
            
            user = cursor.fetchone()
            
            if not user:
                return JsonResponse({
                    'status': 'error',
                    'message': '用户不存在'
                }, status=404)
            
            user_id, username, email, role = user
            
            # 根据角色设置权限
            permissions = []
            if role == 'school_admin':
                permissions = ['all']  # 校级管理员拥有所有权限
            elif role == 'college_admin':
                permissions = ['college', 'teacher', 'resource', 'ai_assistant']  # 院级管理员的权限
            elif role == 'class_admin':
                permissions = ['college', 'teacher']  # 班级管理员的权限
            
            # 返回用户信息
            return JsonResponse({
                'status': 'success',
                'data': {
                    'user_id': user_id,
                    'username': username,
                    'email': email,
                    'role': role,
                    'permissions': permissions
                }
            })
            
    except Exception as e:
        logger.error(f"获取管理员信息失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'服务器内部错误: {str(e)}'
        }, status=500)


@csrf_exempt
def admin_logout(request):
    """
    管理员登出接口
    @route POST /api/auth/admin/logout/
    @description 处理管理员登出请求
    @created 2024-04-08
    """
    if request.method != 'POST':
        return JsonResponse({
            'status': 'error',
            'message': '仅支持POST请求'
        }, status=405)
    
    try:
        # 从请求头获取token
        auth_header = request.META.get('HTTP_AUTHORIZATION', '')
        
        if not auth_header.startswith('Bearer '):
            return JsonResponse({
                'status': 'success',
                'message': '已登出'
            })
        
        token = auth_header.split(' ')[1]
        
        # 验证token
        payload = validate_token(token)
        
        if payload:
            # 记录登出日志
            logout_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            logger.info(f"管理员 {payload.get('username')} 登出成功，时间: {logout_time}")
        
        # 无论token是否有效，都返回登出成功
        # 前端应当在收到成功响应后清除本地存储的token
        return JsonResponse({
            'status': 'success',
            'message': '已登出'
        })
        
    except Exception as e:
        logger.error(f"登出处理失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'服务器内部错误: {str(e)}'
        }, status=500)


@csrf_exempt
def refresh_token(request):
    """
    刷新令牌接口
    @route POST /api/auth/refresh/
    @description 使用旧令牌获取新令牌
    @created 2024-04-08
    """
    if request.method != 'POST':
        return JsonResponse({
            'status': 'error',
            'message': '仅支持POST请求'
        }, status=405)
    
    try:
        # 解析请求体中的JSON数据
        data = json.loads(request.body)
        old_token = data.get('token')
        
        if not old_token:
            return JsonResponse({
                'status': 'error',
                'message': '未提供旧令牌'
            }, status=400)
        
        # 验证旧token
        payload = validate_token(old_token)
        
        if not payload:
            return JsonResponse({
                'status': 'error',
                'message': '令牌无效或已过期'
            }, status=401)
        
        # 生成新token
        new_token = generate_token(
            payload.get('user_id'),
            payload.get('username'),
            payload.get('role')
        )
        
        if not new_token:
            return JsonResponse({
                'status': 'error',
                'message': '生成新令牌失败'
            }, status=500)
        
        # 返回新token
        return JsonResponse({
            'status': 'success',
            'message': '令牌刷新成功',
            'data': {
                'token': new_token
            }
        })
        
    except Exception as e:
        logger.error(f"刷新令牌失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'服务器内部错误: {str(e)}'
        }, status=500)


@csrf_exempt
def user_list(request):
    """
    用户列表接口
    @route GET, POST /api/admin/users/
    @description 获取用户列表或创建新用户
    @created 2024-06-10
    """
    # 验证token
    auth_header = request.META.get('HTTP_AUTHORIZATION', '')
    if not auth_header.startswith('Bearer '):
        return JsonResponse({
            'status': 'error',
            'message': '未提供有效的令牌'
        }, status=401)
    
    token = auth_header.split(' ')[1]
    payload = validate_token(token)
    
    if not payload:
        return JsonResponse({
            'status': 'error',
            'message': '令牌无效或已过期'
        }, status=401)
    
    # 检查是否有权限（只有校级管理员可以管理用户）
    if payload.get('role') != 'school_admin':
        return JsonResponse({
            'status': 'error',
            'message': '权限不足，只有校级管理员可以管理用户'
        }, status=403)
    
    # 处理GET请求 - 获取用户列表
    if request.method == 'GET':
        try:
            with connection.cursor() as cursor:
                # 查询所有管理员用户
                cursor.execute("""
                    SELECT user_id, username, email, role, create_time, status
                    FROM users
                    WHERE role IN ('school_admin', 'college_admin', 'class_admin')
                    ORDER BY create_time DESC
                """)
                
                columns = [col[0] for col in cursor.description]
                users = [dict(zip(columns, row)) for row in cursor.fetchall()]
                
                # 格式化日期时间
                for user in users:
                    if user['create_time']:
                        user['create_time'] = user['create_time'].strftime('%Y-%m-%d %H:%M:%S')
                
                return JsonResponse({
                    'status': 'success',
                    'data': users
                })
                
        except Exception as e:
            logger.error(f"获取用户列表失败: {str(e)}")
            return JsonResponse({
                'status': 'error',
                'message': f'服务器内部错误: {str(e)}'
            }, status=500)
    
    # 处理POST请求 - 创建新用户
    elif request.method == 'POST':
        try:
            data = json.loads(request.body)
            username = data.get('username')
            password = data.get('password')
            name = data.get('name')
            email = data.get('email', '')
            role = data.get('role')
            college_id = data.get('college_id')
            
            # 验证必填字段
            if not all([username, password, role]) or role not in ['school_admin', 'college_admin', 'class_admin']:
                return JsonResponse({
                    'status': 'error',
                    'message': '缺少必要的参数或角色不合法'
                }, status=400)
            
            # 院级和班级管理员需要关联学院
            if role in ['college_admin', 'class_admin'] and not college_id:
                return JsonResponse({
                    'status': 'error',
                    'message': '院级和班级管理员需要指定所属学院'
                }, status=400)
            
            # 检查用户名是否已存在
            with connection.cursor() as cursor:
                cursor.execute("SELECT COUNT(*) FROM users WHERE username = %s", (username,))
                if cursor.fetchone()[0] > 0:
                    return JsonResponse({
                        'status': 'error',
                        'message': '用户名已存在'
                    }, status=400)
                
                # 加密密码
                hashed_password = make_password(password)
                
                # 插入新用户
                cursor.execute("""
                    INSERT INTO users (username, password, email, role, status, create_time)
                    VALUES (%s, %s, %s, %s, %s, %s)
                    RETURNING user_id
                """, (username, hashed_password, email, role, 1, datetime.datetime.now()))
                
                user_id = cursor.fetchone()[0]
                
                # 如果是院级或班级管理员，创建与学院的关联
                if role in ['college_admin', 'class_admin'] and college_id:
                    cursor.execute("""
                        INSERT INTO user_college (user_id, college_id)
                        VALUES (%s, %s)
                    """, (user_id, college_id))
                
                connection.commit()
                
                return JsonResponse({
                    'status': 'success',
                    'message': '用户创建成功',
                    'data': {
                        'user_id': user_id,
                        'username': username,
                        'role': role
                    }
                }, status=201)
                
        except Exception as e:
            logger.error(f"创建用户失败: {str(e)}")
            return JsonResponse({
                'status': 'error',
                'message': f'服务器内部错误: {str(e)}'
            }, status=500)
    
    # 其他请求方法不支持
    return JsonResponse({
        'status': 'error',
        'message': '不支持的请求方法'
    }, status=405)


@csrf_exempt
def college_list(request):
    """
    获取所有学院列表
    @route GET /api/colleges/
    @returns 学院列表
    """
    if request.method == 'GET':
        try:
            # 获取所有学院，按ID排序
            colleges = College.objects.all().order_by('id')
            
            # 如果数据库中没有学院数据，则创建默认学院
            if not colleges.exists():
                # 默认学院数据
                default_colleges = [
                    {'name': '计算机科学与技术学院', 'icon': 'PC', 'description': '培养高素质的计算机科学与技术人才'},
                    {'name': '经济与金融学院', 'icon': '$', 'description': '培养金融经济领域的专业人才'},
                    {'name': '工学院', 'icon': 'E', 'description': '培养机械、自动化等工程技术人才'},
                    {'name': '医学院', 'icon': '+', 'description': '培养医疗卫生领域的专业人才'},
                    {'name': '法学院', 'icon': 'L', 'description': '培养法律领域的专业人才'},
                    {'name': '外国语学院', 'icon': 'G', 'description': '培养外语翻译和国际交流人才'},
                    {'name': '艺术学院', 'icon': 'A', 'description': '培养艺术设计与创作人才'},
                    {'name': '理学院', 'icon': 'S', 'description': '培养数理化等基础科学研究人才'},
                    {'name': '生命科学学院', 'icon': 'B', 'description': '培养生物技术与研究人才'},
                    {'name': '人文学院', 'icon': 'H', 'description': '培养人文社科领域专业人才'},
                    {'name': '新闻传播学院', 'icon': 'N', 'description': '培养新闻传媒领域专业人才'},
                    {'name': '体育学院', 'icon': 'T', 'description': '培养体育运动与教育人才'},
                    {'name': '管理学院', 'icon': 'M', 'description': '培养企业管理与行政管理人才'},
                    {'name': '马克思主义学院', 'icon': 'X', 'description': '培养思想政治教育与理论研究人才'},
                    {'name': '国际教育学院', 'icon': 'I', 'description': '培养国际交流与对外教育人才'}
                ]
                
                # 创建学院数据
                for college_data in default_colleges:
                    College.objects.create(**college_data)
                
                # 重新获取学院列表
                colleges = College.objects.all().order_by('id')
            
            # 准备响应数据
            result = []
            
            # 遍历每个学院，查询班级数和学生数
            for college in colleges:
                logger.info(f"正在处理学院: {college.name} (ID: {college.id})")
                
                try:
                    # 获取该学院下的班级数量
                    class_count = SchoolClass.objects.filter(college=college).count()
                    
                    # 获取该学院下的班级ID列表
                    class_ids = SchoolClass.objects.filter(college=college).values_list('id', flat=True)
                    
                    # 获取这些班级下的学生数量（去重）
                    student_count = 0
                    if class_ids:
                        student_count = StudentClass.objects.filter(class_id__in=class_ids).values('student_id').distinct().count()
                    
                    logger.info(f"学院 {college.name}: 班级数 {class_count}, 学生数 {student_count}")
                except Exception as e:
                    logger.error(f"查询学院 {college.name} 数据出错: {e}")
                    # 如果查询出错，设置为0
                    class_count = 0
                    student_count = 0
                
                # 构建学院信息
                college_info = {
                    'id': college.id,
                    'name': college.name,
                    'icon': college.icon or '?',  # 如果没有图标，显示问号
                    'description': college.description or '暂无描述',  # 如果没有描述，显示默认文本
                    'classCount': class_count,
                    'studentCount': student_count
                }
                
                result.append(college_info)
            
            return JsonResponse({
                'status': 'success',
                'message': '获取成功',
                'data': {
                    'colleges': result
                }
            })
            
        except Exception as e:
            # 记录错误
            logger.error(f"获取学院列表失败: {e}")
            # 返回错误信息
            return JsonResponse({
                'status': 'error',
                'message': f'获取学院列表失败: {e}',
                'data': {
                    'colleges': []
                }
            })
    
            return JsonResponse({
        'status': 'error',
        'message': '不支持的请求方法',
        'data': {
            'colleges': []
        }
    })

@csrf_exempt
def college_detail(request, college_id):
    """
    获取单个学院详情
    @route GET /api/colleges/:id/
    @param college_id 学院ID
    @returns 学院详情
    """
    try:
        # 检查该学院是否存在
        try:
            college = College.objects.get(id=college_id)
        except College.DoesNotExist:
            return JsonResponse({'error': 'College not found'}, status=404)
        
        # 使用ORM查询获取学院信息
        try:
            # 获取该学院下的班级数量
            class_count = SchoolClass.objects.filter(college=college).count()
            
            # 获取该学院下的班级ID列表
            class_ids = SchoolClass.objects.filter(college=college).values_list('id', flat=True)
            
            # 获取这些班级下的学生数量（去重）
            student_count = 0
            if class_ids:
                student_count = StudentClass.objects.filter(class_id__in=class_ids).values('student_id').distinct().count()
            
            logger.info(f"学院 {college.name}: 班级数 {class_count}, 学生数 {student_count}")
            
            # 构建学院详情响应
            college_detail = {
                'id': college.id,
                'name': college.name,
                'icon': college.icon or '?',
                'description': college.description or '暂无描述',
                'classCount': class_count,
                'studentCount': student_count
            }
            
            # 直接返回数据，不使用嵌套结构
            return JsonResponse(college_detail)
            
        except Exception as e:
            logger.error(f"查询学院 {college.name} 详情出错: {e}")
            class_count = 0
            student_count = 0
            
            # 学院图标映射表，提供默认图标
            college_icons = {
                '计算机科学与技术学院': '💻',
                '经济与金融学院': '💰',
                '工学院': '⚙️',
                '医学院': '🏥',
                '法学院': '⚖️',
                '外国语学院': '🌏',
                '艺术学院': '🎨',
                '理学院': '🔬',
                '生命科学学院': '🧬',
                '人文学院': '📚',
                '新闻传播学院': '📰',
                '体育学院': '🏃',
                '管理学院': '📊',
                '马克思主义学院': '📖',
                '国际教育学院': '🌍',
                '环境科学学院': '🌱',
                '建筑学院': '🏛️',
                '材料科学学院': '🔋',
                '化学工程学院': '⚗️',
                '电子信息学院': '📡'
            }
            
            # 学院描述映射表
            college_descriptions = {
                '计算机科学与技术学院': '培养高素质的计算机科学与技术人才',
                '经济与金融学院': '培养金融经济领域的专业人才',
                '工学院': '培养机械、自动化等工程技术人才',
                '医学院': '培养医疗卫生领域的专业人才',
                '法学院': '培养法律领域的专业人才',
                '外国语学院': '培养外语翻译和国际交流人才',
                '艺术学院': '培养艺术设计与创作人才',
                '理学院': '培养数理化等基础科学研究人才',
                '生命科学学院': '培养生物技术与研究人才',
                '人文学院': '培养人文社科研究人才',
                '新闻传播学院': '培养新闻传媒专业人才', 
                '体育学院': '培养体育教育与训练人才',
                '管理学院': '培养企业管理与行政管理人才',
                '马克思主义学院': '培养思政教育与研究人才',
                '国际教育学院': '培养国际交流与合作人才',
                '环境科学学院': '培养环境保护与治理人才',
                '建筑学院': '培养建筑设计与城市规划人才',
                '材料科学学院': '培养新材料研发与应用人才',
                '化学工程学院': '培养化工工艺与技术人才',
                '电子信息学院': '培养电子信息技术人才'
            }
            
            # 使用默认图标和描述
            icon = college_icons.get(college.name, '🏫')
            description = college_descriptions.get(college.name, '暂无描述')
            
            # 构建学院详情响应
            college_detail = {
                'id': college.id,
                'name': college.name,
                'icon': icon,
                'description': description,
                'classCount': class_count,
                'studentCount': student_count
            }
            
            # 直接返回数据，不使用嵌套结构
            return JsonResponse(college_detail)
            
    except Exception as e:
        logger.exception(f"获取学院详情失败: {str(e)}")
        return JsonResponse({
            'error': f'获取学院详情失败: {str(e)}'
        }, status=500)

@csrf_exempt
def college_classes(request, college_id):
    """
    获取学院下的班级列表
    @route GET /api/colleges/:id/classes/
    @param college_id 学院ID
    @returns 班级列表
    """
    try:
        # 验证学院是否存在
        try:
            college = College.objects.get(id=college_id)
            print(f"找到学院: {college.name} (ID: {college_id})")
        except College.DoesNotExist:
            print(f"未找到学院ID: {college_id}")
            return JsonResponse({'error': 'College not found'}, status=404)
        
        if request.method == 'GET':
            with connection.cursor() as cursor:
                # 检查该学院是否已有年级数据
                cursor.execute("""
                    SELECT COUNT(*)
                    FROM school_grades
                    WHERE college_id = %s
                """, [college_id])
                grade_count = cursor.fetchone()[0] or 0
                print(f"学院 {college.name} (ID: {college_id}) 的年级数量: {grade_count}")
                
                # 如果没有年级数据，创建默认年级和班级
                if grade_count == 0:
                    print(f"为学院 {college.name} (ID: {college_id}) 创建默认年级和班级数据")
                    
                    # 定义学院专业映射
                    college_majors = {
                        '计算机科学与技术学院': ['计算机科学与技术', '软件工程', '人工智能', '数据科学与大数据技术'],
                        '经济与金融学院': ['金融学', '国际经济与贸易', '经济学', '金融工程'],
                        '工学院': ['机械工程', '自动化', '电气工程及其自动化', '工业设计'],
                        '医学院': ['临床医学', '医学检验技术', '护理学', '药学'],
                        '法学院': ['法学', '知识产权', '国际法', '法律事务'],
                        '外国语学院': ['英语', '日语', '法语', '翻译'],
                        '艺术学院': ['设计学', '美术学', '音乐学', '戏剧影视文学'],
                        '理学院': ['数学与应用数学', '物理学', '化学', '统计学'],
                        '生命科学学院': ['生物科学', '生物技术', '生态学', '食品科学与工程'],
                        '环境科学学院': ['环境工程', '环境科学', '资源环境科学', '环境生态学'],
                        '建筑学院': ['建筑学', '城乡规划', '风景园林', '建筑环境与能源应用工程'],
                        '材料科学学院': ['材料科学与工程', '高分子材料与工程', '复合材料与工程', '材料物理'],
                        '化学工程学院': ['化学工程与工艺', '制药工程', '应用化学', '能源化学工程'],
                        '电子信息学院': ['电子信息工程', '通信工程', '电子科学与技术', '光电信息科学与工程'],
                        '人文学院': ['汉语言文学', '历史学', '哲学', '文化产业管理'],
                        '新闻传播学院': ['新闻学', '广告学', '网络与新媒体', '传播学'],
                        '体育学院': ['体育教育', '运动训练', '社会体育指导与管理', '休闲体育'],
                        '管理学院': ['工商管理', '市场营销', '会计学', '人力资源管理'],
                        '马克思主义学院': ['思想政治教育', '马克思主义理论', '政治学与行政学', '中国近现代史'],
                        '国际教育学院': ['国际事务与国际关系', '国际商务', '跨文化研究', '全球发展与合作']
                    }
                    
                    # 获取当前学院的专业，确保至少有3个专业
                    majors = college_majors.get(college.name, ['专业1', '专业2', '专业3', '专业4'])
                    
                    # 创建年级数据 - 2022级到2024级
                    grades = []
                    for year in [2022, 2023, 2024]:
                        cursor.execute("""
                            INSERT INTO school_grades (name, college_id)
                            VALUES (%s, %s)
                        """, [f"{year}级", college_id])
                        
                        grade_id = cursor.lastrowid
                        connection.commit()
                        grades.append({'id': grade_id, 'name': f"{year}级"})
                        print(f"创建年级: {year}级, ID: {grade_id}")
                    
                    # 为每个年级创建班级数据
                    teacher_names = ['张老师', '李老师', '王老师', '赵老师', '钱老师', '孙老师', '周老师', '吴老师']
                    
                    for grade in grades:
                        for idx, major in enumerate(majors, 1):
                            # 每个专业创建2个班，确保至少有6个班级
                            for class_num in [1, 2]:
                                # 计算学生人数（28-35之间随机）
                                student_count = 28 + (idx * 2 + class_num) % 8
                                
                                # 班主任分配
                                teacher_idx = (idx + class_num) % len(teacher_names)
                                teacher_name = teacher_names[teacher_idx]
                                
                                # 创建班级
                                try:
                                    # 确保学生数量在25-35之间
                                    if student_count < 25:
                                        student_count = 28 + (idx * 2 + class_num) % 8
                                        print(f"调整学生数量为: {student_count}")
                                        
                                    cursor.execute("""
                                        INSERT INTO school_classes (name, grade_id, teacher_name, student_count)
                                        VALUES (%s, %s, %s, %s)
                                    """, [f"{major}{class_num}班", grade['id'], teacher_name, student_count])
                                    
                                    connection.commit()
                                    print(f"成功创建班级: {major}{class_num}班, 年级ID: {grade['id']}, 学生数: {student_count}")
                                except Exception as e:
                                    print(f"创建班级出错: {major}{class_num}班, 错误: {str(e)}")
                                    # 继续尝试创建其他班级
                    
                    print(f"已完成学院 {college.name} 的班级数据创建")
                
                # 校验创建是否成功，如果没有班级，重新尝试创建
                cursor.execute("""
                    SELECT COUNT(*)
                    FROM school_classes sc
                    JOIN school_grades sg ON sc.grade_id = sg.id
                    WHERE sg.college_id = %s
                """, [college_id])
                class_count = cursor.fetchone()[0] or 0
                
                if class_count == 0:
                    print(f"学院 {college.name} 没有班级数据，将重新创建")
                    
                    # 尝试删除可能存在的年级数据（可能是创建了年级但没有创建班级）
                    cursor.execute("""
                        DELETE FROM school_grades WHERE college_id = %s
                    """, [college_id])
                    connection.commit()
                    
                    # 重新创建年级和班级数据
                    majors = college_majors.get(college.name, ['专业1', '专业2', '专业3'])
                    teacher_names = ['张老师', '李老师', '王老师', '赵老师']
                    
                    # 创建年级
                    grades = []
                    for year in [2022, 2023, 2024]:
                        try:
                            cursor.execute("""
                                INSERT INTO school_grades (name, college_id)
                                VALUES (%s, %s)
                            """, [f"{year}级", college_id])
                            
                            grade_id = cursor.lastrowid
                            connection.commit()
                            grades.append({'id': grade_id, 'name': f"{year}级"})
                            print(f"重新创建年级: {year}级, ID: {grade_id}")
                        except Exception as e:
                            print(f"重新创建年级错误: {year}级, 错误: {str(e)}")
                    
                    # 为每个年级创建班级
                    for grade in grades:
                        for idx, major in enumerate(majors, 1):
                            for class_num in [1, 2]:
                                student_count = 30 + idx % 6
                                teacher_name = teacher_names[idx % len(teacher_names)]
                                
                                try:
                                    # 确保学生数是一个合理的数字（30-35）
                                    if student_count < 25:
                                        student_count = 30 + (idx + class_num) % 6
                                    
                                    cursor.execute("""
                                        INSERT INTO school_classes (name, grade_id, teacher_name, student_count)
                                        VALUES (%s, %s, %s, %s)
                                    """, [f"{major}{class_num}班", grade['id'], teacher_name, student_count])
                                    
                                    connection.commit()
                                    print(f"重新创建班级: {major}{class_num}班, 年级ID: {grade['id']}, 学生数: {student_count}")
                                except Exception as e:
                                    print(f"重新创建班级出错: {major}{class_num}班, 错误: {str(e)}")
                
                # 查询该学院所有班级信息
                cursor.execute("""
                    SELECT 
                        sc.id, sc.name, sc.grade_id, sg.name as grade_name, 
                        sc.teacher_name, sc.student_count
                    FROM school_classes sc
                    JOIN school_grades sg ON sc.grade_id = sg.id
                    WHERE sg.college_id = %s
                    ORDER BY sg.name DESC, sc.name ASC
                """, [college_id])
                
                classes = cursor.fetchall()
                print(f"查询到学院 {college.name} (ID: {college_id}) 的班级数量: {len(classes) if classes else 0}")
                
                if classes:
                    print("班级数据样本:")
                    for i, class_obj in enumerate(classes[:3]):  # 只打印前3个班级
                        print(f"  班级 {i+1}: ID={class_obj[0]}, 名称={class_obj[1]}, 年级ID={class_obj[2]}, 年级名称={class_obj[3]}")
                else:
                    print(f"警告: 未找到学院 {college.name} (ID: {college_id}) 的班级数据")
                
                # 返回数据
                data = []
                for class_obj in classes:
                    # 确保学生数量不为0，如果为0则根据班级ID生成一个固定值
                    student_count = class_obj[5]
                    if not student_count or student_count == 0:
                        # 根据班级ID生成固定的学生数量(25-35之间)
                        student_count = 25 + (class_obj[0] % 10)
                        print(f"班级 {class_obj[1]} 学生数为0，设置为 {student_count}")
                    
                    class_data = {
                        'id': class_obj[0],
                        'name': class_obj[1],
                        'gradeId': class_obj[2],
                        'gradeName': class_obj[3],
                        'teacherName': class_obj[4] or '未分配',
                        'studentCount': student_count
                    }
                    data.append(class_data)
                
                print(f"返回的JSON数据长度: {len(data)}")
                if data:
                    print(f"第一个班级数据示例: {data[0]}")
                
                return JsonResponse(data, safe=False)
            
        elif request.method == 'POST':
            # 创建新班级
            try:
                data = json.loads(request.body)
                grade_id = data.get('gradeId')
                name = data.get('name')
                
                if not grade_id or not name:
                    return JsonResponse({'error': 'Grade ID and name are required'}, status=400)
                
                # 验证年级是否存在且属于当前学院
                with connection.cursor() as cursor:
                    cursor.execute("""
                        SELECT id
                        FROM school_grades
                        WHERE id = %s AND college_id = %s
                    """, [grade_id, college_id])
                    
                    if not cursor.fetchone():
                        return JsonResponse({'error': 'Grade not found'}, status=404)
                    
                    # 创建新班级
                    cursor.execute("""
                        INSERT INTO school_classes (name, grade_id, teacher_name)
                        VALUES (%s, %s, %s)
                    """, [name, grade_id, data.get('teacherName')])
                    
                    class_id = cursor.lastrowid
                    
                    return JsonResponse({
                        'id': class_id,
                        'name': name,
                        'gradeId': grade_id,
                        'gradeName': '',  # 需要额外查询
                        'teacherName': data.get('teacherName') or '未分配',
                        'studentCount': 0
                    }, status=201)
            except Exception as e:
                return JsonResponse({'error': str(e)}, status=400)
    except Exception as e:
        print(f"获取学院班级失败: {str(e)}")
        
        # 检查数据库连接是否正常
        try:
            with connection.cursor() as cursor:
                cursor.execute("SELECT 1")
                if cursor.fetchone():
                    print("数据库连接正常")
                    
                    # 尝试创建必要的表
                    try:
                        # 检查表是否存在
                        cursor.execute("SHOW TABLES LIKE 'school_grades'")
                        if not cursor.fetchone():
                            cursor.execute("""
                                CREATE TABLE school_grades (
                                    id INT AUTO_INCREMENT PRIMARY KEY,
                                    name VARCHAR(50) NOT NULL,
                                    college_id INT NOT NULL
                                )
                            """)
                            connection.commit()
                            print("紧急创建school_grades表")
                        
                        cursor.execute("SHOW TABLES LIKE 'school_classes'")
                        if not cursor.fetchone():
                            cursor.execute("""
                                CREATE TABLE school_classes (
                                    id INT AUTO_INCREMENT PRIMARY KEY,
                                    name VARCHAR(50) NOT NULL,
                                    grade_id INT NOT NULL,
                                    teacher_name VARCHAR(50),
                                    student_count INT DEFAULT 0
                                )
                            """)
                            connection.commit()
                            print("紧急创建school_classes表")
                            
                        # 尝试为指定学院创建数据
                        if college_id:
                            college_name = getattr(college, 'name', '未知学院')
                            print(f"尝试为学院 {college_name} (ID: {college_id}) 紧急创建班级数据")
                            
                            # 创建年级
                            for year in [2022, 2023, 2024]:
                                cursor.execute("""
                                    INSERT INTO school_grades (name, college_id)
                                    VALUES (%s, %s)
                                """, [f"{year}级", college_id])
                                
                                grade_id = cursor.lastrowid
                                connection.commit()
                                
                                # 为每个年级创建班级
                                for i in range(1, 3):
                                    for j in range(1, 3):
                                        class_name = f"专业{i}{j}班"
                                        student_count = 30 + i + j
                                        teacher_name = f"老师{i+j}"
                                        
                                        cursor.execute("""
                                            INSERT INTO school_classes (name, grade_id, teacher_name, student_count)
                                            VALUES (%s, %s, %s, %s)
                                        """, [class_name, grade_id, teacher_name, student_count])
                                        
                                        connection.commit()
                                        print(f"紧急创建班级: {class_name}")
                            
                            print("紧急创建完成，重新加载页面")
                            
                            # 查询创建的班级
                            cursor.execute("""
                                SELECT 
                                    sc.id, sc.name, sc.grade_id, sg.name as grade_name, 
                                    sc.teacher_name, sc.student_count
                                FROM school_classes sc
                                JOIN school_grades sg ON sc.grade_id = sg.id
                                WHERE sg.college_id = %s
                                ORDER BY sg.name DESC, sc.name ASC
                            """, [college_id])
                            
                            classes = cursor.fetchall()
                            
                            # 返回数据
                            data = []
                            for class_obj in classes:
                                data.append({
                                    'id': class_obj[0],
                                    'name': class_obj[1],
                                    'gradeId': class_obj[2],
                                    'gradeName': class_obj[3],
                                    'teacherName': class_obj[4] or '未分配',
                                    'studentCount': class_obj[5] or 0
                                })
                            
                            return JsonResponse(data, safe=False)
                    
                    except Exception as e2:
                        print(f"紧急创建表或数据出错: {str(e2)}")
        
        except Exception as db_error:
            print(f"数据库连接异常: {str(db_error)}")
        
        return JsonResponse({'error': f'服务器内部错误: {str(e)}，请联系管理员检查数据库'}, status=500)
    
    return JsonResponse({'error': 'Method not allowed'}, status=405)

@csrf_exempt
def class_detail(request, college_id, grade_id, class_id):
    """
    获取班级详情
    @route GET /api/colleges/:college_id/grades/:grade_id/classes/:class_id/
    @param college_id 学院ID
    @param grade_id 年级ID
    @param class_id 班级ID
    @returns 班级详情
    """
    try:
        # 验证学院、年级和班级
        with connection.cursor() as cursor:
            # 验证学院
            cursor.execute("SELECT name FROM colleges WHERE id = %s", [college_id])
            college = cursor.fetchone()
            if not college:
                return JsonResponse({'error': 'College not found'}, status=404)
                
            # 验证年级
            cursor.execute("""
                SELECT name 
                FROM school_grades 
                WHERE id = %s AND college_id = %s
            """, [grade_id, college_id])
            grade = cursor.fetchone()
            if not grade:
                return JsonResponse({'error': 'Grade not found'}, status=404)
                
            # 验证班级
            cursor.execute("""
                SELECT name, teacher_name, student_count
                FROM school_classes
                WHERE id = %s AND grade_id = %s
            """, [class_id, grade_id])
            class_obj = cursor.fetchone()
            if not class_obj:
                return JsonResponse({'error': 'Class not found'}, status=404)
                
            if request.method == 'GET':
                # 计算班级平均分 - 确保使用正确的列名
                cursor.execute("""
                    SELECT AVG(score) 
                    FROM school_students
                    WHERE class_id = %s
                """, [class_id])
                avg_score = cursor.fetchone()[0] or 0
                if avg_score:
                    avg_score = round(float(avg_score), 1)
                    
                # 计算排名（模拟数据）
                ranking = 2  # 假设排名为第二
                
                # 课程数（模拟数据）
                course_count = 8
                
                data = {
                    'id': int(class_id),
                    'name': class_obj[0],
                    'college': college[0],
                    'grade': grade[0],
                    'teacherName': class_obj[1] or '未分配',
                    'studentCount': class_obj[2] or 0,
                    'courseCount': course_count,
                    'avgScore': avg_score,
                    'ranking': ranking
                }
                
                return JsonResponse(data)
    except Exception as e:
        print(f"获取班级详情失败: {str(e)}")
        return JsonResponse({
            'error': f'服务器内部错误: {str(e)}'
        }, status=500)
    
    return JsonResponse({'error': 'Method not allowed'}, status=405)

@csrf_exempt
def class_students(request, college_id, grade_id, class_id):
    """
    获取班级学生列表
    @route GET /api/colleges/:college_id/grades/:grade_id/classes/:class_id/students/
    @param college_id 学院ID
    @param grade_id 年级ID
    @param class_id 班级ID
    @returns 学生列表
    """
    if request.method != 'GET':
        return JsonResponse({'error': 'Only GET method is supported'}, status=405)
        
    try:
        # 验证学院、年级和班级
        with connection.cursor() as cursor:
            # 验证学院
            cursor.execute("SELECT id FROM colleges WHERE id = %s", [college_id])
            if not cursor.fetchone():
                return JsonResponse({'error': 'College not found'}, status=404)
                
            # 验证年级
            cursor.execute("""
                SELECT id 
                FROM school_grades 
                WHERE id = %s AND college_id = %s
            """, [grade_id, college_id])
            if not cursor.fetchone():
                return JsonResponse({'error': 'Grade not found'}, status=404)
                
            # 验证班级
            cursor.execute("""
                SELECT id
                FROM school_classes
                WHERE id = %s AND grade_id = %s
            """, [class_id, grade_id])
            if not cursor.fetchone():
                return JsonResponse({'error': 'Class not found'}, status=404)
                
            # 获取班级学生列表 - 从真实的students表获取数据
            try:
                cursor.execute("""
                    SELECT s.student_id, s.name, s.email, s.enrollment_date
                    FROM students s
                    JOIN student_class sc ON s.student_id = sc.student_id
                    WHERE sc.class_id = %s
                    ORDER BY s.student_id
                """, [class_id])
                
                students = cursor.fetchall()
                
                print(f"查询到班级 {class_id} 的学生数量: {len(students) if students else 0}")
                
                data = []
                for i, student in enumerate(students):
                    # 为每个学生生成一些随机数据
                    attendance = round(random.uniform(0.7, 1.0), 2)  # 70%-100%的出勤率
                    score = round(random.uniform(60, 95), 1)  # 60-95分的随机成绩
                    
                    # 构建学生信息
                    student_id, name, email, enrollment_date = student
                    student_data = {
                        'id': student_id,
                        'name': name,
                        'email': email,
                        'attendance': str(attendance * 100) + '%',
                        'score': score,
                        'rank': i + 1
                    }
                    
                    data.append(student_data)
                
                if not data:
                    print(f"警告：班级 {class_id} 没有找到任何学生")
                    
            except Exception as e:
                print(f"查询班级学生时出错: {e}")
                # 出错时返回空列表
                data = []
                
                return JsonResponse(data, safe=False)
            
    except Exception as e:
        print(f"获取班级学生失败: {str(e)}")
        return JsonResponse({
            'error': f'服务器内部错误: {str(e)}'
        }, status=500)

@csrf_exempt
def class_analysis(request, college_id, grade_id, class_id, analysis_type):
    """
    获取班级分析数据
    @route GET /api/colleges/:college_id/grades/:grade_id/classes/:class_id/analysis/:analysis_type/
    @param college_id 学院ID
    @param grade_id 年级ID
    @param class_id 班级ID
    @param analysis_type 分析类型(learning|behavior|performance)
    @returns 班级分析数据
    """
    if request.method != 'GET':
        return JsonResponse({'error': 'Only GET method is supported'}, status=405)
    
    logger.info(f"获取班级分析数据: college_id={college_id}, grade_id={grade_id}, class_id={class_id}, type={analysis_type}")
    
    try:
        # 连接数据库
        connection = get_db_connection()
        if not connection:
            return JsonResponse({'error': 'Database connection failed'}, status=500)
        
        with connection.cursor() as cursor:
            # 检查班级是否存在
            cursor.execute("SELECT COUNT(*) FROM school_classes WHERE id = %s", [class_id])
            if cursor.fetchone()[0] == 0:
                return JsonResponse({'error': 'Class not found'}, status=404)
            
            # 获取班级名称
            cursor.execute("SELECT name FROM school_classes WHERE id = %s", [class_id])
            class_name = cursor.fetchone()[0]
            
            # 先检查是否存在class_learning_analysis表
            cursor.execute("""
                SELECT COUNT(*) 
                FROM information_schema.tables 
                WHERE table_name = 'class_learning_analysis'
            """)
            
            if cursor.fetchone()[0] == 0:
                # 如果表不存在，创建表
                logger.info("创建class_learning_analysis表")
                cursor.execute("""
                    CREATE TABLE IF NOT EXISTS class_learning_analysis (
                        id INT AUTO_INCREMENT PRIMARY KEY,
                        class_id INT NOT NULL,
                        analysis_type VARCHAR(20) NOT NULL,
                        stats TEXT,
                        grade_distribution TEXT,
                        knowledge_mastery TEXT,
                        learning_progress TEXT,
                        homework_status TEXT,
                        recommendations TEXT,
                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                        INDEX (class_id, analysis_type)
                    )
                """)
                connection.commit()

            # 检查是否已有该班级的分析数据
            cursor.execute("""
                SELECT stats, grade_distribution, knowledge_mastery, 
                learning_progress, homework_status, recommendations
                FROM class_learning_analysis
                WHERE class_id = %s AND analysis_type = %s
            """, [class_id, analysis_type])
            
            analysis_data = cursor.fetchone()
            if analysis_data:
                logger.info(f"在class_learning_analysis表中找到班级(ID: {class_id})的{analysis_type}分析数据")
                
                # 解析查询结果
                stats = json.loads(analysis_data[0]) if analysis_data[0] else {}
                grade_distribution = json.loads(analysis_data[1]) if analysis_data[1] else {}
                knowledge_mastery = json.loads(analysis_data[2]) if analysis_data[2] else {}
                learning_progress = json.loads(analysis_data[3]) if analysis_data[3] else {}
                homework_status = json.loads(analysis_data[4]) if analysis_data[4] else {}
                recommendations = json.loads(analysis_data[5]) if analysis_data[5] else []
            else:
                # 如果没有找到数据，生成模拟数据并保存到数据库
                logger.info(f"没有找到班级(ID: {class_id})的{analysis_type}分析数据，创建模拟数据")
                
                # 获取学生数量
                cursor.execute("""
                    SELECT COUNT(*) 
                    FROM student_class 
                    WHERE class_id = %s
                """, [class_id])
                result = cursor.fetchone()
                student_count = result[0] if result else 30  # 默认30名学生
                
                # 生成统计数据
                avg_score = round(random.uniform(75, 90), 1)
                pass_rate = random.randint(85, 98)
                homework_completion_rate = random.randint(80, 95)
                attendance_rate = random.randint(90, 99)
                
                stats = {
                    'avg_score': avg_score,
                    'pass_rate': pass_rate,
                    'homework_completion_rate': homework_completion_rate,
                    'attendance_rate': attendance_rate,
                    'score_change': round(random.uniform(-2, 5), 1),
                    'pass_rate_change': round(random.uniform(-1, 3), 1),
                    'homework_completion_change': round(random.uniform(-1, 4), 1),
                    'attendance_change': round(random.uniform(-1, 2), 1)
                }
                
                # 生成成绩分布
                grade_distribution = {
                    'categories': ['90-100', '80-89', '70-79', '60-69', '<60'],
                    'values': [
                        int(student_count * random.uniform(0.1, 0.25)),  # 优秀
                        int(student_count * random.uniform(0.3, 0.5)),   # 良好
                        int(student_count * random.uniform(0.15, 0.3)),  # 中等
                        int(student_count * random.uniform(0.05, 0.15)), # 及格
                        int(student_count * random.uniform(0, 0.05))     # 不及格
                    ]
                }
                
                # 根据班级名称确定学科领域
                subject_areas = []
                if '计算机' in class_name or '软件' in class_name or '网络' in class_name:
                    subject_areas = ['数据结构', '算法分析', '编程基础', '数据库', '计算机网络']
                elif '数学' in class_name or '统计' in class_name:
                    subject_areas = ['高等数学', '线性代数', '概率论', '数学分析', '离散数学']
                elif '物理' in class_name:
                    subject_areas = ['力学', '电磁学', '热学', '光学', '量子物理']
                elif '化学' in class_name:
                    subject_areas = ['有机化学', '无机化学', '物理化学', '分析化学', '生物化学']
                elif '生物' in class_name:
                    subject_areas = ['分子生物学', '细胞生物学', '遗传学', '生态学', '微生物学']
                elif '外语' in class_name or '英语' in class_name:
                    subject_areas = ['听力', '口语', '阅读', '写作', '语法']
                elif '经济' in class_name or '金融' in class_name:
                    subject_areas = ['微观经济学', '宏观经济学', '金融学', '会计学', '统计学']
                elif '医学' in class_name or '护理' in class_name:
                    subject_areas = ['解剖学', '生理学', '病理学', '药理学', '临床医学']
                else:
                    # 默认通用知识点
                    subject_areas = ['理论基础', '专业知识', '实践技能', '创新能力', '综合素质']
                
                # 生成知识点掌握情况
                knowledge_mastery = {
                    'indicator': subject_areas,
                    'data': [round(random.uniform(70, 95)) for _ in range(len(subject_areas))]
                }
                
                # 生成学习进度
                weeks = ['第1周', '第2周', '第3周', '第4周', '第5周', '第6周']
                learning_progress = {
                    'weeks': weeks,
                    'progress': [round(random.uniform(60, 95)) for _ in range(len(weeks))]
                }
                
                # 生成作业完成情况
                homework_status = {
                    'categories': ['按时提交', '延迟提交', '未提交'],
                    'values': [
                        int(student_count * random.uniform(0.7, 0.9)),  # 按时提交
                        int(student_count * random.uniform(0.05, 0.2)), # 延迟提交
                        int(student_count * random.uniform(0, 0.1))     # 未提交
                    ]
                }
                
                # 生成学习建议
                recommendations = [
                    {
                        'title': '加强知识点巩固',
                        'content': f'建议针对{knowledge_mastery["indicator"][knowledge_mastery["data"].index(min(knowledge_mastery["data"]))]}知识点进行重点巩固，可通过增加练习题和小组讨论来提高掌握程度。'
                    },
                    {
                        'title': '优化学习方法',
                        'content': '建议学生采用更加多样化的学习方法，如思维导图、概念图等可视化工具帮助理解和记忆复杂概念。'
                    },
                    {
                        'title': '提高课堂参与度',
                        'content': '鼓励学生积极参与课堂讨论，提问和回答问题，增强师生互动，提高学习效果。'
                    },
                    {
                        'title': '加强实践环节',
                        'content': '增加实验和实践环节，将理论知识与实际应用相结合，提高学生的动手能力和问题解决能力。'
                    }
                ]
                
                # 保存到数据库
                cursor.execute("""
                    INSERT INTO class_learning_analysis 
                    (class_id, analysis_type, stats, grade_distribution, knowledge_mastery, 
                    learning_progress, homework_status, recommendations)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                """, [
                    class_id, 
                    analysis_type, 
                    json.dumps(stats), 
                    json.dumps(grade_distribution),
                    json.dumps(knowledge_mastery),
                    json.dumps(learning_progress),
                    json.dumps(homework_status),
                    json.dumps(recommendations)
                ])
                connection.commit()
            
            # 构建响应数据
            response_data = {
                'stats': stats,
                'grade_distribution': grade_distribution,
                'knowledge_mastery': knowledge_mastery,
                'learning_progress': learning_progress,
                'homework_status': homework_status,
                'recommendations': recommendations
            }
            
            return JsonResponse(response_data)
            
    except Exception as e:
        logger.exception(f"获取班级分析数据失败: {str(e)}")
        return JsonResponse({'error': f'Failed to retrieve class analysis data: {str(e)}'}, status=500)
    finally:
        if connection:
            connection.close()

@csrf_exempt
def class_student_learning(request, college_id, grade_id, class_id, student_id):
    """
    获取班级中某个学生的学习情况
    @route GET /api/colleges/:college_id/grades/:grade_id/classes/:class_id/students/:student_id/learning/
    @param college_id 学院ID
    @param grade_id 年级ID
    @param class_id 班级ID
    @param student_id 学生ID
    @returns 学生学习情况数据
    """
    if request.method != 'GET':
        return JsonResponse({'error': 'Only GET method is supported'}, status=405)
    
    logger.info(f"获取学生学习情况: college_id={college_id}, grade_id={grade_id}, class_id={class_id}, student_id={student_id}")
    
    try:
        # 连接数据库
        connection = get_db_connection()
        if not connection:
            return JsonResponse({'error': 'Database connection failed'}, status=500)
        
        with connection.cursor() as cursor:
            # 验证学生是否存在
            cursor.execute("""
                SELECT s.student_id, s.name
                FROM students s
                JOIN student_class sc ON s.student_id = sc.student_id
                WHERE s.student_id = %s AND sc.class_id = %s
            """, [student_id, class_id])
            
            student = cursor.fetchone()
            if not student:
                # 如果没有找到，尝试只通过学生ID查询
                cursor.execute("SELECT student_id, name FROM students WHERE student_id = %s", [student_id])
                student = cursor.fetchone()
                if not student:
                    return JsonResponse({'error': 'Student not found'}, status=404)
            
            student_id = student[0]
            student_name = student[1]
            
            # 查询学生学习数据
            cursor.execute("""
                SELECT * FROM student_learning_data
                WHERE student_id = %s
            """, [student_id])
            
            learning_data = cursor.fetchone()
            
            if learning_data:
                logger.info(f"找到学生(ID: {student_id})的学习数据")
                
                # 获取学习数据的列名
                cursor.execute("DESCRIBE student_learning_data")
                columns = [column[0] for column in cursor.fetchall()]
                
                # 将查询结果转换为字典
                learning_dict = {}
                for i, column in enumerate(columns):
                    if column in ['grade_distribution', 'knowledge_mastery', 'learning_progress', 
                                 'learning_behavior', 'courses', 'recommendations', 'weekly_plan']:
                        if learning_data[i]:
                            learning_dict[column] = json.loads(learning_data[i])
                        else:
                            learning_dict[column] = None
                    else:
                        learning_dict[column] = learning_data[i]
                
                # 构建响应数据
                response_data = {
                    'student_id': student_id,
                    'name': student_name,
                    'academic': {
                        'avg_score': str(learning_dict.get('avg_score', 0)),
                        'rank': learning_dict.get('class_rank', 0),
                        'rank_change': learning_dict.get('rank_change', 0),
                        'attendance_rate': str(learning_dict.get('attendance_rate', 0)),
                        'attendance_change': str(learning_dict.get('attendance_change', 0))
                    },
                    'grade_distribution': learning_dict.get('grade_distribution', {}),
                    'knowledge_mastery': learning_dict.get('knowledge_mastery', {}),
                    'learning_progress': learning_dict.get('learning_progress', {}),
                    'learning_behavior': learning_dict.get('learning_behavior', {}),
                    'courses': learning_dict.get('courses', []),
                    'recommendations': learning_dict.get('recommendations', []),
                    'weekly_plan': learning_dict.get('weekly_plan', [])
                }
                
                return JsonResponse(response_data)
            
            # 如果没有找到学习数据，则调用student_detail接口获取数据
            logger.info(f"未找到学生(ID: {student_id})的学习数据，调用student_detail接口")
            
            # 创建一个模拟的请求对象
            mock_request = type('MockRequest', (), {'method': 'GET'})()
            
            # 调用student_detail函数
            student_detail_response = student_detail(mock_request, student_id)
            
            # 解析响应数据
            if hasattr(student_detail_response, 'content'):
                response_data = json.loads(student_detail_response.content)
                return JsonResponse(response_data)
            else:
                return student_detail_response
            
    except Exception as e:
        logger.exception(f"获取学生学习情况失败: {str(e)}")
        return JsonResponse({'error': f'Failed to retrieve student learning data: {str(e)}'}, status=500)
    finally:
        if connection:
            connection.close()

@csrf_exempt
def student_detail(request, student_id):
    """
    获取学生详情
    @param request: HTTP请求
    @param student_id: 学生ID
    @return: 学生详情JSON
    """
    if request.method != 'GET':
        return JsonResponse({'error': 'Only GET method is supported'}, status=405)
    
    logger.info(f"获取学生详情: student_id={student_id}")
    
    connection = None
    try:
        # 连接数据库
        connection = get_db_connection()
        if not connection:
            return JsonResponse({'error': 'Database connection failed'}, status=500)
        
        with connection.cursor() as cursor:
            # 先检查是否存在student_learning_data表
            cursor.execute("""
                SELECT COUNT(*) 
                FROM information_schema.tables 
                WHERE table_name = 'student_learning_data'
            """)
            
            if cursor.fetchone()[0] == 0:
                # 如果表不存在，创建表
                logger.info("创建student_learning_data表")
                cursor.execute("""
                    CREATE TABLE IF NOT EXISTS student_learning_data (
                        id INT AUTO_INCREMENT PRIMARY KEY,
                        student_id INT NOT NULL,
                        name VARCHAR(100),
                        college VARCHAR(100),
                        grade VARCHAR(50),
                        class_name VARCHAR(100),
                        avg_score DECIMAL(5,2),
                        class_rank INT,
                        attendance_rate DECIMAL(5,2),
                        score_change DECIMAL(5,2),
                        rank_change INT,
                        attendance_change DECIMAL(5,2),
                        grade_distribution TEXT,
                        knowledge_mastery TEXT,
                        learning_progress TEXT,
                        learning_behavior TEXT,
                        courses TEXT,
                        recommendations TEXT,
                        weekly_plan TEXT,
                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                        UNIQUE KEY (student_id)
                    )
                """)
                connection.commit()
            
            # 首先尝试从student_learning_data表获取数据
            cursor.execute("""
                SELECT name, college, grade, class_name, avg_score, class_rank, 
                       attendance_rate, score_change, rank_change, attendance_change,
                       grade_distribution, knowledge_mastery, learning_progress, 
                       learning_behavior, courses, recommendations, weekly_plan
                FROM student_learning_data
                WHERE student_id = %s
            """, [student_id])
            
            learning_data = cursor.fetchone()
            
                        # 获取学生基本信息
            cursor.execute("""
                SELECT s.*, 
                       scl.class_id, 
                       sc.name as class_name, 
                       sg.name as grade_name,
                       c.name as college_name
                FROM students s
                LEFT JOIN student_class scl ON s.student_id = scl.student_id
                LEFT JOIN school_classes sc ON scl.class_id = sc.id
                LEFT JOIN school_grades sg ON sc.grade_id = sg.id
                LEFT JOIN colleges c ON sg.college_id = c.id
                WHERE s.student_id = %s
            """, [student_id])
            
            student_info = cursor.fetchone()
            if not student_info:
                return JsonResponse({'error': 'Student not found'}, status=404)
            
            student_id = student_info[0]
            name = student_info[1]
            email = student_info[2]
            enrollment_date = student_info[3]
            class_id = student_info[4] if len(student_info) > 4 else None
            class_name = student_info[5] if len(student_info) > 5 else "未分配班级"
            grade_name = student_info[6] if len(student_info) > 6 else "未知年级"
            college_name = student_info[7] if len(student_info) > 7 else "未知学院"
            
            if learning_data:
                logger.info(f"在student_learning_data表中找到学生(ID: {student_id})的学习数据")
                
                # 解析数据
                name = learning_data[0] or name
                college = learning_data[1] or college_name
                grade = learning_data[2] or grade_name
                class_name = learning_data[3] or class_name
                avg_score = learning_data[4]
                rank = learning_data[5]
                attendance_rate = learning_data[6]
                score_change = learning_data[7]
                rank_change = learning_data[8]
                attendance_change = learning_data[9]
                grade_distribution = json.loads(learning_data[10]) if learning_data[10] else {}
                knowledge_mastery = json.loads(learning_data[11]) if learning_data[11] else {}
                learning_progress = json.loads(learning_data[12]) if learning_data[12] else {}
                learning_behavior = json.loads(learning_data[13]) if learning_data[13] else {}
                courses = json.loads(learning_data[14]) if learning_data[14] else []
                recommendations = json.loads(learning_data[15]) if learning_data[15] else []
                weekly_plan = json.loads(learning_data[16]) if learning_data[16] else {}
            else:
                # 如果没有找到数据，生成模拟数据并保存
                logger.info(f"没有找到学生(ID: {student_id})的学习数据，创建模拟数据")
                
                # 生成随机学术数据
                avg_score = round(random.uniform(75, 95), 1)
                rank = random.randint(1, 30)
                rank_change = random.randint(-3, 3)
                attendance_rate = round(random.uniform(85, 99), 1)
                attendance_change = round(random.uniform(-1, 2), 1)
                
                # 生成成绩分布
                grade_distribution = {
                    'categories': ['90-100', '80-89', '70-79', '60-69', '<60'],
                    'values': [
                        random.randint(0, 5),
                        random.randint(2, 8),
                        random.randint(1, 5),
                        random.randint(0, 3),
                        random.randint(0, 2)
                    ]
                }
                
                # 根据学生所在班级或学院确定学科领域
                subject_areas = []
                if college_name:
                    if '计算机' in college_name or '软件' in college_name:
                        subject_areas = ['数据结构', '算法分析', '编程基础', '数据库', '计算机网络']
                    elif '数学' in college_name:
                        subject_areas = ['高等数学', '线性代数', '概率论', '数学分析', '离散数学']
                    elif '物理' in college_name:
                        subject_areas = ['力学', '电磁学', '热学', '光学', '量子物理']
                    elif '化学' in college_name:
                        subject_areas = ['有机化学', '无机化学', '物理化学', '分析化学', '生物化学']
                    elif '生物' in college_name:
                        subject_areas = ['分子生物学', '细胞生物学', '遗传学', '生态学', '微生物学']
                    elif '外语' in college_name or '英语' in college_name:
                        subject_areas = ['听力', '口语', '阅读', '写作', '语法']
                    elif '经济' in college_name or '金融' in college_name:
                        subject_areas = ['微观经济学', '宏观经济学', '金融学', '会计学', '统计学']
                    elif '医学' in college_name:
                        subject_areas = ['解剖学', '生理学', '病理学', '药理学', '临床医学']
                    else:
                        # 默认通用知识点
                        subject_areas = ['理论基础', '专业知识', '实践技能', '创新能力', '综合素质']
                else:
                    # 默认通用知识点
                    subject_areas = ['理论基础', '专业知识', '实践技能', '创新能力', '综合素质']
                
                # 生成知识点掌握情况
                knowledge_mastery = {
                    'indicator': subject_areas,
                    'data': [round(random.uniform(70, 95)) for _ in range(len(subject_areas))]
                }
                
                # 生成学习进度
                weeks = ['第1周', '第2周', '第3周', '第4周', '第5周', '第6周']
                learning_progress = {
                    'weeks': weeks,
                    'progress': [round(random.uniform(60, 95)) for _ in range(len(weeks))]
                }
                
                # 生成学习行为数据
                learning_behavior = {
                    'categories': ['课堂参与度', '专注时长', '提问频率', '小组贡献度', '自主学习'],
                    'data': [
                        round(random.uniform(70, 95)),
                        round(random.uniform(65, 90)),
                        round(random.uniform(60, 85)),
                        round(random.uniform(75, 95)),
                        round(random.uniform(70, 90))
                    ]
                }
                
                # 生成课程数据
                course_names = [
                    '高等数学', '大学英语', '程序设计基础', '数据结构', 
                    '计算机网络', '操作系统', '数据库原理', '软件工程',
                    '人工智能', '机器学习', '计算机组成原理', '编译原理'
                ]
                teachers = ['张老师', '李老师', '王老师', '赵老师', '刘老师', '陈老师']
                
                courses = []
                for i in range(5):  # 生成5门课程
                    if i < len(course_names):
                        course_name = course_names[i]
                    else:
                        course_name = f'课程{i+1}'
                    
                    courses.append({
                        'id': i + 1,
                        'name': course_name,
                        'teacher': random.choice(teachers),
                        'score': round(random.uniform(70, 98)),
                        'rank': random.randint(1, 30),
                        'attendance': round(random.uniform(85, 100))
                    })
                
                # 生成学习建议
                recommendations = [
                    {
                        'title': '知识点巩固',
                        'content': f'建议针对{knowledge_mastery["indicator"][knowledge_mastery["data"].index(min(knowledge_mastery["data"]))]}知识点进行重点巩固，可通过增加练习题和小组讨论来提高掌握程度。'
                    },
                    {
                        'title': '学习方法优化',
                        'content': '建议采用更加多样化的学习方法，如思维导图、概念图等可视化工具帮助理解和记忆复杂概念。'
                    },
                    {
                        'title': '时间管理',
                        'content': '建议制定更合理的学习计划，分配适当的时间给不同科目，尤其是需要加强的弱项科目。'
                    }
                ]
                
                # 生成每周学习计划
                days = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
                weekly_plan = []
                
                for day in days:
                    day_plan = {
                        'day': day,
                        'items': []
                    }
                    
                    # 工作日安排3-4个学习任务，周末安排1-2个
                    task_count = random.randint(3, 4) if day not in ['周六', '周日'] else random.randint(1, 2)
                    
                    time_slots = ['8:00-10:00', '10:30-12:00', '14:00-16:00', '16:30-18:00', '19:00-21:00']
                    tasks = [
                        f'复习{random.choice(subject_areas)}',
                        f'完成{random.choice(course_names)}作业',
                        f'预习{random.choice(course_names)}',
                        f'练习{random.choice(subject_areas)}题目',
                        f'小组讨论{random.choice(subject_areas)}',
                        f'整理{random.choice(course_names)}笔记',
                        '自主学习',
                        '在线课程学习'
                    ]
                    
                    used_slots = []
                    for _ in range(task_count):
                        # 选择未使用的时间段
                        available_slots = [slot for slot in time_slots if slot not in used_slots]
                        if not available_slots:
                            break
                        
                        time_slot = random.choice(available_slots)
                        used_slots.append(time_slot)
                        
                        day_plan['items'].append({
                            'time': time_slot,
                            'task': random.choice(tasks)
                        })
                    
                    # 确保时间顺序正确
                    day_plan['items'].sort(key=lambda x: time_slots.index(x['time']) if x['time'] in time_slots else 999)
                    
                    weekly_plan.append(day_plan)
                
                # 保存到数据库
                cursor.execute("""
                    INSERT INTO student_learning_data
                    (student_id, name, college, grade, class_name, avg_score, class_rank, 
                    attendance_rate, score_change, rank_change, attendance_change,
                    grade_distribution, knowledge_mastery, learning_progress, 
                    learning_behavior, courses, recommendations, weekly_plan)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                """, [
                    student_id, name, college_name, grade_name, class_name, avg_score, rank,
                    attendance_rate, score_change, rank_change, attendance_change,
                    json.dumps(grade_distribution), json.dumps(knowledge_mastery), 
                    json.dumps(learning_progress), json.dumps(learning_behavior),
                    json.dumps(courses), json.dumps(recommendations), json.dumps(weekly_plan)
                ])
                connection.commit()
                
                # 构建响应数据
                response_data = {
                    'student_id': student_id,
                    'name': name,
                    'email': email,
                    'enrollment_date': enrollment_date.strftime('%Y-%m-%d') if enrollment_date else None,
                    'college': college_name,
                    'grade': grade_name,
                    'class': class_name,
                    'status': '在读',  # 假设状态为在读
                    'academic': {
                        'avg_score': str(avg_score),
                        'rank': rank,
                        'rank_change': rank_change,
                        'attendance_rate': str(attendance_rate),
                        'attendance_change': str(attendance_change)
                    },
                    'grade_distribution': grade_distribution,
                    'knowledge_mastery': knowledge_mastery,
                    'learning_progress': learning_progress,
                    'learning_behavior': learning_behavior,
                    'courses': courses,
                    'recommendations': recommendations,
                    'weekly_plan': weekly_plan
                }
            
                return JsonResponse(response_data)
            
    except Exception as e:
        logger.exception(f"获取学生详情出错: {str(e)}")
        return JsonResponse({'error': f'Failed to retrieve student details: {str(e)}'}, status=500)
    finally:
        if connection:
            connection.close()


@csrf_exempt
def student_attendance(request, student_id):
    """
    学生出勤记录接口
    @route GET /api/students/<int:student_id>/attendance/
    @route POST /api/students/<int:student_id>/attendance/
    @description 获取或添加学生出勤记录
    @created 2024-06-15
    """
    from django.db.models import Count, Case, When, IntegerField
    from .models import AttendanceRecord
    
    try:
        # 检查学生是否存在
        try:
            student = Student.objects.get(student_id=student_id)
        except ObjectDoesNotExist:
            return JsonResponse({
                'status': 'error',
                'message': f'ID为{student_id}的学生不存在'
            }, status=404)
        
        # 处理GET请求 - 获取出勤记录
        if request.method == 'GET':
            # 获取出勤记录
            attendance_records = AttendanceRecord.objects.filter(student_id=student_id)
            
            # 按课程分组统计出勤情况
            attendance_stats = attendance_records.values('course_id').annotate(
                total=Count('attendance_id'),
                present=Count(Case(When(status=1, then=1), output_field=IntegerField())),
                absent=Count(Case(When(status=0, then=1), output_field=IntegerField())),
                leave=Count(Case(When(status=2, then=1), output_field=IntegerField()))
            )
            
            # 构建出勤数据
            attendance_data = []
            for stat in attendance_stats:
                # 查询课程信息
                with connection.cursor() as cursor:
                    cursor.execute("""
                        SELECT name FROM courses WHERE course_id = %s
                    """, [stat['course_id']])
                    result = cursor.fetchone()
                    course_name = result[0] if result else f"未知课程({stat['course_id']})"
                
                # 计算出勤率
                attendance_rate = 0
                if stat['total'] > 0:
                    attendance_rate = round((stat['present'] / stat['total']) * 100, 2)
                
                # 构建课程出勤数据
                course_attendance = {
                    'course_id': stat['course_id'],
                    'course_name': course_name,
                    'total_classes': stat['total'],
                    'present': stat['present'],
                    'absent': stat['absent'],
                    'leave': stat['leave'],
                    'attendance_rate': attendance_rate
                }
                
                attendance_data.append(course_attendance)
            
            # 获取最近的出勤记录
            recent_records = []
            for record in attendance_records.order_by('-class_date')[:10]:
                # 查询课程信息
                with connection.cursor() as cursor:
                    cursor.execute("""
                        SELECT name FROM courses WHERE course_id = %s
                    """, [record.course_id])
                    result = cursor.fetchone()
                    course_name = result[0] if result else f"未知课程({record.course_id})"
                
                # 构建出勤记录
                record_data = {
                    'attendance_id': record.attendance_id,
                    'course_name': course_name,
                    'class_date': record.class_date.strftime('%Y-%m-%d'),
                    'status': record.status,
                    'status_text': '出勤' if record.status == 1 else ('缺勤' if record.status == 0 else '请假')
                }
                
                recent_records.append(record_data)
            
            # 返回出勤数据
            return JsonResponse({
                'status': 'success',
                'data': {
                    'attendance_stats': attendance_data,
                    'recent_records': recent_records
                }
            })
        
        # 处理POST请求 - 添加出勤记录
        elif request.method == 'POST':
            # 解析请求数据
            data = json.loads(request.body)
            course_id = data.get('course_id')
            class_date = data.get('class_date')
            status = data.get('status', 1)  # 默认为出勤
            
            # 验证请求参数
            if not all([course_id, class_date]):
                return JsonResponse({
                    'status': 'error',
                    'message': '必填字段不能为空'
                }, status=400)
            
            # 创建出勤记录
            record = AttendanceRecord(
                student_id=student_id,
                course_id=course_id,
                class_date=class_date,
                status=status
            )
            record.save()
            
            # 返回创建的记录
            return JsonResponse({
                'status': 'success',
                'message': '出勤记录添加成功',
                'data': {
                    'attendance_id': record.attendance_id,
                    'student_id': record.student_id,
                    'course_id': record.course_id,
                    'class_date': record.class_date.strftime('%Y-%m-%d'),
                    'status': record.status
                }
            }, status=201)
        
        else:
            return JsonResponse({
                'status': 'error',
                'message': '不支持的请求方法'
            }, status=405)
    
    except Exception as e:
        logger.error(f"处理学生出勤记录请求失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理学生出勤记录请求失败: {str(e)}'
        }, status=500)


@csrf_exempt
def student_courses(request, student_id):
    """
    学生课程接口
    @route GET /api/students/<int:student_id>/courses/
    @description 获取学生课程信息
    @created 2024-06-15
    """
    try:
        # 检查学生是否存在
        try:
            student = Student.objects.get(student_id=student_id)
        except ObjectDoesNotExist:
            return JsonResponse({
                'status': 'error',
                'message': f'ID为{student_id}的学生不存在'
            }, status=404)
        
        # 处理GET请求 - 获取课程信息
        if request.method == 'GET':
            # 查询学生的成绩信息，通过成绩表关联课程
            with connection.cursor() as cursor:
                cursor.execute("""
                    SELECT c.course_id, c.name, t.teacher_name, g.final_grade
                    FROM courses c
                    JOIN grades g ON c.course_id = g.course_id
                    LEFT JOIN teaching_record tr ON c.course_id = tr.course_id
                    LEFT JOIN teacher t ON tr.teacher_id = t.teacher_id
                    WHERE g.student_id = %s
                """, [student_id])
                
                courses = []
                for row in cursor.fetchall():
                    course_id, course_name, teacher_name, final_grade = row
                    
                    # 查询出勤信息
                    cursor.execute("""
                        SELECT COUNT(*) FROM attendance_records 
                        WHERE student_id = %s AND course_id = %s AND status = 1
                    """, [student_id, course_id])
                    attended_count = cursor.fetchone()[0]
                    
                    cursor.execute("""
                        SELECT COUNT(*) FROM attendance_records 
                        WHERE student_id = %s AND course_id = %s
                    """, [student_id, course_id])
                    total_count = cursor.fetchone()[0]
                    
                    # 计算出勤率
                    attendance_rate = 0
                    if total_count > 0:
                        attendance_rate = round((attended_count / total_count) * 100, 2)
                    else:
                        # 如果没有记录，默认给一个高出勤率
                        attendance_rate = 85.0 + (student_id % 15)  # 随机分配出勤率以模拟真实数据
                    
                    # 构建课程信息
                    course_data = {
                        'course_id': course_id,
                        'course_name': course_name,
                        'teacher_name': teacher_name if teacher_name else '未分配教师',
                        'final_grade': float(final_grade) if final_grade else 0,
                        'attendance_rate': attendance_rate
                    }
                    
                    courses.append(course_data)
            
            # 返回课程数据
            return JsonResponse({
                'status': 'success',
                'data': courses
            })
        
        else:
            return JsonResponse({
                'status': 'error',
                'message': '不支持的请求方法'
            }, status=405)
    
    except Exception as e:
        logger.error(f"获取学生课程信息失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取学生课程信息失败: {str(e)}'
        }, status=500)

@csrf_exempt
def test_student_detail(request):
    """
    专门测试学生ID为20230101026的学生详情API
    @route GET /api/test/student/20230101026/
    @description 测试获取指定ID学生的详情信息
    @created 2024-06-15
    """
    print("==== 测试API - 学生详情请求 ====")
    print("固定学生ID: 20230101026")
    
    try:
        # 直接构建一个硬编码的响应数据
        import random
        
        student_data = {
            'id': 20230101026,
            'name': '马奔英',
            'email': 'test@example.com',
            'enrollment_date': '2023-09-01',
            'score': 90.5,
            'scoreChange': '+5%',
            'rank': 1,
            'rankChange': '+2%',
            'attendance': 91.68,
            'attendanceChange': '+1%',
            'courseCount': 6,
            'courseCountChange': '+0%',
            'className': '计算机科学1班',
            
            # 成绩分布数据
            'grade_distribution': {
                'excellent': 50,
                'good': 30,
                'average': 15,
                'poor': 5
            },
            
            # 学习进度追踪数据
            'learning_progress': [
                {'subject': '高等数学', 'completion': 85},
                {'subject': '计算机基础', 'completion': 90},
                {'subject': 'C语言程序设计', 'completion': 88}
            ],
            
            # 知识点掌握情况数据
            'knowledge_mastery': [
                {'area': '数据结构', 'level': 85},
                {'area': '数据库', 'level': 80},
                {'area': '算法分析', 'level': 75},
                {'area': '操作系统', 'level': 82},
                {'area': '计算机网络', 'level': 78}
            ],
            
            # 学习行为分析数据
            'learning_behavior': [
                {'week': '周一', 'class_participation': 90, 'assignment_completion': 92, 'self_study': 85},
                {'week': '周二', 'class_participation': 85, 'assignment_completion': 90, 'self_study': 88},
                {'week': '周三', 'class_participation': 92, 'assignment_completion': 88, 'self_study': 86},
                {'week': '周四', 'class_participation': 88, 'assignment_completion': 90, 'self_study': 85},
                {'week': '周五', 'class_participation': 90, 'assignment_completion': 85, 'self_study': 90}
            ],
            
            # 课程成绩数据
            'courses': [
                {
                    'id': 1,
                    'name': '高等数学',
                    'score': 87.5,
                    'rank': 8,
                    'attendance_rate': 92.5,
                    'teacher_name': '王老师'
                },
                {
                    'id': 2,
                    'name': '大学英语',
                    'score': 90.2,
                    'rank': 5,
                    'attendance_rate': 94.0,
                    'teacher_name': '李老师'
                },
                {
                    'id': 3,
                    'name': '计算机基础',
                    'score': 85.8,
                    'rank': 10,
                    'attendance_rate': 90.5,
                    'teacher_name': '张老师'
                },
                {
                    'id': 4,
                    'name': '数据结构',
                    'score': 82.3,
                    'rank': 12,
                    'attendance_rate': 88.5,
                    'teacher_name': '刘老师'
                },
                {
                    'id': 5,
                    'name': 'C语言程序设计',
                    'score': 89.6,
                    'rank': 7,
                    'attendance_rate': 93.0,
                    'teacher_name': '陈老师'
                },
                {
                    'id': 6,
                    'name': '数据库原理',
                    'score': 84.9,
                    'rank': 11,
                    'attendance_rate': 91.5,
                    'teacher_name': '赵老师'
                }
            ]
        }
        
        print("成功生成测试学生数据，返回响应")
        return JsonResponse(student_data)
        
    except Exception as e:
        print(f"测试API处理失败: {str(e)}")
        return JsonResponse({
            'error': f'Error processing test API: {str(e)}',
            'stack_trace': str(e.__traceback__)
        }, status=500)

@csrf_exempt
def dynamic_student_detail(request, student_id):
    """
    动态测试学生详情API，可以处理任何学生ID
    @route GET /api/test/dynamic-student/:student_id/
    @description 为任何学生ID生成测试数据
    @created 2024-06-15
    """
    print(f"==== 动态测试API - 学生详情请求 ====")
    print(f"学生ID: {student_id}")
    
    try:
        # 根据学生ID生成唯一但固定的随机数据
        # 为了保证同一ID每次返回相同数据，使用ID作为随机种子
        import random
        # 设置随机种子，保证同一ID每次生成相同的"随机"数据
        random.seed(int(student_id) % 10000)
        
        # 根据学生ID的最后一位确定学生姓名
        last_digit = int(student_id) % 10
        first_names = ['张', '李', '王', '赵', '钱', '孙', '周', '吴', '郑', '马']
        last_names = ['明', '华', '强', '勇', '伟', '杰', '鹏', '飞', '宇', '奔英']
        
        student_name = first_names[last_digit] + last_names[last_digit]
        
        # 构建响应数据
        student_data = {
            'id': int(student_id),
            'name': student_name,
            'email': f'student{student_id}@example.com',
            'enrollment_date': '2023-09-01',
            'score': round(random.uniform(80, 95), 1),
            'scoreChange': '+5%',
            'rank': random.randint(1, 10),
            'rankChange': '+2%',
            'attendance': round(random.uniform(85, 98), 2),
            'attendanceChange': '+1%',
            'courseCount': 6,
            'courseCountChange': '+0%',
            'className': '计算机科学1班',
            
            # 成绩分布数据
            'grade_distribution': {
                'excellent': round(random.uniform(40, 60)),
                'good': round(random.uniform(20, 40)),
                'average': round(random.uniform(10, 20)),
                'poor': round(random.uniform(0, 10))
            },
            
            # 学习进度追踪数据
            'learning_progress': [
                {'subject': '高等数学', 'completion': round(random.uniform(75, 95))},
                {'subject': '计算机基础', 'completion': round(random.uniform(80, 95))},
                {'subject': 'C语言程序设计', 'completion': round(random.uniform(75, 95))}
            ],
            
            # 知识点掌握情况数据
            'knowledge_mastery': [
                {'area': '数据结构', 'level': round(random.uniform(70, 90))},
                {'area': '数据库', 'level': round(random.uniform(70, 90))},
                {'area': '算法分析', 'level': round(random.uniform(65, 85))},
                {'area': '操作系统', 'level': round(random.uniform(70, 90))},
                {'area': '计算机网络', 'level': round(random.uniform(60, 85))}
            ],
            
            # 学习行为分析数据
            'learning_behavior': [
                {'week': '周一', 'class_participation': round(random.uniform(80, 95)), 'assignment_completion': round(random.uniform(80, 95)), 'self_study': round(random.uniform(75, 90))},
                {'week': '周二', 'class_participation': round(random.uniform(80, 95)), 'assignment_completion': round(random.uniform(80, 95)), 'self_study': round(random.uniform(75, 90))},
                {'week': '周三', 'class_participation': round(random.uniform(80, 95)), 'assignment_completion': round(random.uniform(80, 95)), 'self_study': round(random.uniform(75, 90))},
                {'week': '周四', 'class_participation': round(random.uniform(80, 95)), 'assignment_completion': round(random.uniform(80, 95)), 'self_study': round(random.uniform(75, 90))},
                {'week': '周五', 'class_participation': round(random.uniform(80, 95)), 'assignment_completion': round(random.uniform(80, 95)), 'self_study': round(random.uniform(75, 90))}
            ],
            
            # 课程成绩数据
            'courses': [
                {
                    'id': 1,
                    'name': '高等数学',
                    'score': round(random.uniform(75, 95), 1),
                    'rank': random.randint(1, 20),
                    'attendance_rate': round(random.uniform(85, 95), 1),
                    'teacher_name': '王老师'
                },
                {
                    'id': 2,
                    'name': '大学英语',
                    'score': round(random.uniform(75, 95), 1),
                    'rank': random.randint(1, 20),
                    'attendance_rate': round(random.uniform(85, 95), 1),
                    'teacher_name': '李老师'
                },
                {
                    'id': 3,
                    'name': '计算机基础',
                    'score': round(random.uniform(75, 95), 1),
                    'rank': random.randint(1, 20),
                    'attendance_rate': round(random.uniform(85, 95), 1),
                    'teacher_name': '张老师'
                },
                {
                    'id': 4,
                    'name': '数据结构',
                    'score': round(random.uniform(75, 95), 1),
                    'rank': random.randint(1, 20),
                    'attendance_rate': round(random.uniform(85, 95), 1),
                    'teacher_name': '刘老师'
                },
                {
                    'id': 5,
                    'name': 'C语言程序设计',
                    'score': round(random.uniform(75, 95), 1),
                    'rank': random.randint(1, 20),
                    'attendance_rate': round(random.uniform(85, 95), 1),
                    'teacher_name': '陈老师'
                },
                {
                    'id': 6,
                    'name': '数据库原理',
                    'score': round(random.uniform(75, 95), 1),
                    'rank': random.randint(1, 20),
                    'attendance_rate': round(random.uniform(85, 95), 1),
                    'teacher_name': '赵老师'
                }
            ]
        }
        
        print(f"成功为学生ID {student_id} 生成测试数据")
        return JsonResponse(student_data)
        
    except Exception as e:
        print(f"动态测试API处理失败: {str(e)}")
        return JsonResponse({
            'error': f'Error processing dynamic test API: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["POST"])
def ai_classify_document(request):
    """
    文档分类AI功能
    @param request: HTTP请求对象，应包含文件
    @return: 分类结果JsonResponse
    """
    try:
        if 'file' not in request.FILES:
            return JsonResponse({
                'status': 'error',
                'message': '未提供文件'
            }, status=400)
            
        uploaded_file = request.FILES['file']
        
        # 实际项目中，这里应该调用Dify API
        # 模拟Dify文档分类API调用
        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
        
        # 根据文件类型生成不同的分类标签
        tags = []
        main_category = ''
        
        if file_extension in ['.doc', '.docx']:
            tags = [
                {'name': '文档', 'confidence': 0.98},
                {'name': '教学资料', 'confidence': 0.92}
            ]
            main_category = '课程文档'
            
        elif file_extension in ['.ppt', '.pptx']:
            tags = [
                {'name': '演示文稿', 'confidence': 0.97},
                {'name': '课件', 'confidence': 0.94}
            ]
            main_category = '教学课件'
            
        elif file_extension == '.pdf':
            tags = [
                {'name': 'PDF文档', 'confidence': 0.99},
                {'name': '教材资料', 'confidence': 0.90}
            ]
            main_category = '学习资料'
            
        elif file_extension in ['.mp4', '.avi', '.mov']:
            tags = [
                {'name': '视频', 'confidence': 0.98},
                {'name': '多媒体', 'confidence': 0.95}
            ]
            main_category = '教学视频'
            
        else:
            tags = [
                {'name': '未知类型', 'confidence': 0.70},
                {'name': '教学资源', 'confidence': 0.85}
            ]
            main_category = '其他资源'
            
        # 添加文件名相关标签
        filename_words = os.path.splitext(uploaded_file.name)[0].lower().split('_')
        for word in filename_words:
            if len(word) > 1:  # 忽略单字符词
                # 将文件名中的关键词添加为标签
                tags.append({
                    'name': word,
                    'confidence': 0.82
                })
        
        # 返回分类结果
        return JsonResponse({
            'status': 'success',
            'tags': tags,
            'mainCategory': main_category,
            'message': '文件分类成功'
        })
        
    except Exception as e:
        logger.error(f"文档分类错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["POST"])
def ai_evaluate_quality(request):
    """
    评估资源质量
    @param request: HTTP请求对象
    @return: 质量评估结果JsonResponse
    """
    try:
        data = json.loads(request.body)
        resource_id = data.get('id')
        content = data.get('content', '')
        
        if not resource_id:
            return JsonResponse({
                'status': 'error',
                'message': '未提供资源ID'
            }, status=400)
            
        # 模拟Dify质量评估API调用
        evaluation_results = {
            'overall_score': 87,
            'aspects': [
                {
                    'name': '内容准确性',
                    'score': 92,
                    'comments': '内容准确无误，符合教学标准',
                    'suggestions': ['可添加更多实例说明']
                },
                {
                    'name': '教学价值',
                    'score': 85,
                    'comments': '较好地覆盖了课程要点',
                    'suggestions': ['建议增加互动环节', '可以添加更多思考问题']
                },
                {
                    'name': '表达清晰度',
                    'score': 88,
                    'comments': '表达清晰，结构合理',
                    'suggestions': ['可简化部分复杂术语解释']
                },
                {
                    'name': '适用性',
                    'score': 83,
                    'comments': '适合目标学生使用',
                    'suggestions': ['可提供不同难度版本', '增加适合不同学习风格的内容']
                }
            ],
            'improvement_suggestions': [
                '添加更多实例和练习题',
                '增加视觉辅助内容，如图表和图像',
                '简化部分复杂的解释，使内容更易理解',
                '添加更多互动和自测环节'
            ]
        }
        
        return JsonResponse({
            'status': 'success',
            'data': evaluation_results,
            'message': '质量评估完成'
        })
        
    except Exception as e:
        logger.error(f"质量评估错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def ai_get_recommendations(request):
    """
    获取个性化资源推荐
    @param request: HTTP请求对象
    @return: 推荐结果JsonResponse
    """
    try:
        user_id = request.GET.get('userId')
        subject = request.GET.get('subject', '')
        tags = request.GET.getlist('tags', [])
        
        if not user_id:
            return JsonResponse({
                'status': 'error',
                'message': '未提供用户ID'
            }, status=400)
            
        # 模拟Dify推荐API调用
        recommended_resources = [
            {
                'id': 1001,
                'title': '高等数学基础教程',
                'type': '教材',
                'format': 'PDF',
                'match_score': 95,
                'tags': ['数学', '微积分', '教材'],
                'description': '全面覆盖高等数学基础知识，适合大一学生学习'
            },
            {
                'id': 1002,
                'title': '物理学入门实验视频',
                'type': '视频',
                'format': 'MP4',
                'match_score': 92,
                'tags': ['物理', '实验', '视频教程'],
                'description': '包含10个基础物理实验的详细演示和讲解'
            },
            {
                'id': 1003,
                'title': '编程基础习题集',
                'type': '习题',
                'format': 'DOC',
                'match_score': 88,
                'tags': ['编程', '习题', '实践'],
                'description': '200道精选编程基础习题，包含详细解答'
            }
        ]
        
        return JsonResponse({
            'status': 'success',
            'data': {
                'recommendations': recommended_resources,
                'total': len(recommended_resources),
                'recommendation_factors': [
                    '用户历史学习行为',
                    '课程内容关联度',
                    '学习进度匹配度'
                ]
            },
            'message': '推荐成功'
        })
        
    except Exception as e:
        logger.error(f"获取推荐错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["POST"])
def ai_optimize_format(request):
    """
    资源格式优化转换
    @param request: HTTP请求对象
    @return: 转换结果JsonResponse
    """
    try:
        data = json.loads(request.body)
        resource_id = data.get('resourceId')
        target_format = data.get('targetFormat')
        optimization_options = data.get('optimizationOptions', {})
        
        if not resource_id or not target_format:
            return JsonResponse({
                'status': 'error',
                'message': '缺少必要参数'
            }, status=400)
            
        # 模拟Dify转换API调用
        optimization_result = {
            'original_format': 'DOC',
            'target_format': target_format,
            'optimized_file_url': f'/api/resources/optimized/{resource_id}.{target_format.lower()}',
            'optimization_details': [
                '已优化图像质量',
                '已调整布局以适应多种设备',
                '已优化文件大小',
                '已添加交互式元素'
            ],
            'size_reduction': '35%'
        }
        
        return JsonResponse({
            'status': 'success',
            'data': optimization_result,
            'message': '资源优化完成'
        })
        
    except Exception as e:
        logger.error(f"格式优化错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["POST"])
def ai_dify_message(request):
    """
    调用Dify消息API
    @param request: HTTP请求对象
    @return: Dify响应JsonResponse
    """
    try:
        data = json.loads(request.body)
        query = data.get('query', '')
        inputs = data.get('inputs', {})
        app_id = data.get('appId', DIFY_APP_ID)
        
        if not query:
            return JsonResponse({
                'status': 'error',
                'message': '未提供查询文本'
            }, status=400)
            
        # 实际应用中应调用Dify API
        # 模拟Dify响应
        dify_response = {
            'answer': f'对于"{query}"的回答：这是AI助手的回答。实际应用中，这里会调用Dify API获取真实回答。',
            'conversation_id': f'conv_{hash(query) % 10000}',
            'created_at': '2024-06-26T12:34:56Z'
        }
        
        return JsonResponse({
            'status': 'success',
            'data': dify_response,
            'message': '处理成功'
        })
        
    except Exception as e:
        logger.error(f"Dify消息错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["POST"])
def ai_upload_to_knowledge_base(request):
    """
    上传文件到Dify知识库
    @param request: HTTP请求对象
    @return: 上传结果JsonResponse
    """
    try:
        if 'file' not in request.FILES:
            return JsonResponse({
                'status': 'error',
                'message': '未提供文件'
            }, status=400)
            
        uploaded_file = request.FILES['file']
        knowledge_base_id = request.POST.get('knowledge_base_id', '')
        
        if not knowledge_base_id:
            return JsonResponse({
                'status': 'error',
                'message': '未提供知识库ID'
            }, status=400)
            
        # 实际应用中应调用Dify知识库API
        # 模拟上传结果
        upload_result = {
            'document_id': f'doc_{hash(uploaded_file.name) % 10000}',
            'file_name': uploaded_file.name,
            'status': 'processing'
        }
        
        return JsonResponse({
            'status': 'success',
            'data': upload_result,
            'message': '文件已上传至知识库，正在处理'
        })
        
    except Exception as e:
        logger.error(f"知识库上传错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'处理失败: {str(e)}'
        }, status=500)

# 添加Dify API调用函数
def analyze_resource_with_dify(resource_path, resource_name):
    """
    调用Dify API分析资源
    @param resource_path 资源文件路径
    @param resource_name 资源名称
    @return 分析结果JSON
    """
    try:
        # 首先上传文件到Dify知识库
        dify_doc_id = 0
        knowledge_base_id = os.environ.get('DIFY_KNOWLEDGE_BASE_ID', 'kb-1')
        
        try:
            # 打开文件
            with open(resource_path, 'rb') as f:
                file_data = f.read()
            
            # 上传到Dify知识库
            files = {"file": (os.path.basename(resource_path), file_data)}
            upload_headers = {'Authorization': f'Bearer {DIFY_API_KEY}'}
            
            upload_response = requests.post(
                f"{DIFY_API_URL}/knowledge-bases/{knowledge_base_id}/documents",
                headers=upload_headers,
                files=files
            )
            
            if upload_response.status_code == 200 or upload_response.status_code == 201:
                upload_result = upload_response.json()
                dify_doc_id = upload_result.get('id', 0)
                print(f"文件成功上传到Dify，文档ID: {dify_doc_id}")
            else:
                print(f"上传文件到Dify失败: {upload_response.status_code} - {upload_response.text}")
        except Exception as upload_error:
            print(f"上传文件到Dify时发生错误: {str(upload_error)}")
        
        # 构造请求数据 - 包含更多文件信息
        file_extension = os.path.splitext(resource_path)[1].lower()
        file_info = f"文件名：{resource_name}，文件类型：{file_extension}，文件路径：{resource_path}"
        
        # 调用Dify聊天API进行文件分析
        headers = {
            'Authorization': 'Bearer app-DOCeW1vaO6JU7QmuANvdnPUG',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'query': '请分析这个教学资源，并以JSON格式返回以下信息：tags(标签数组)、confidence(置信度0-1)、mainCategory(主分类)、subCategory(子分类)、subjectArea(学科领域)、educationalValue(教育价值)、recommendedUses(推荐用途数组)',
            'inputs': {
                'file_info': file_info
            },
            'response_mode': 'blocking',  # 阻塞模式，等待完整结果
            'conversation_id': ''
        }
        
        response = requests.post(
            'http://121.40.242.43/v1/chat-messages',
            headers=headers,
            json=payload
        )
        
        if response.status_code == 200:
            result = response.json()
            # 尝试从回复中提取JSON
            answer = result.get('answer', '{}')
            try:
                # 寻找JSON部分
                json_start = answer.find('{')
                json_end = answer.rfind('}') + 1
                if json_start >= 0 and json_end > json_start:
                    json_str = answer[json_start:json_end]
                    analysis_result = json.loads(json_str)
                    # 添加dify_doc_id到结果中
                    analysis_result['dify_doc_id'] = dify_doc_id
                    return analysis_result
                return {'dify_doc_id': dify_doc_id}
            except Exception as json_error:
                print(f"解析JSON回复出错: {str(json_error)}")
                return {'dify_doc_id': dify_doc_id}
        return {'dify_doc_id': dify_doc_id}
    except Exception as e:
        print(f"分析资源出错: {str(e)}")
        return {'dify_doc_id': 0}

@csrf_exempt
@require_http_methods(["POST"])
def resource_upload(request):
    """
    上传教学资源接口
    @route POST /api/admin/resource/upload/
    @description 上传文件并写入Resource表，返回结果
    @created 2024-06-26
    """
    try:
        file = request.FILES.get('file')
        resource_name = request.POST.get('resource_name')
        creator_id = request.POST.get('creator_id')
        
        if not file or not resource_name or not creator_id:
            return JsonResponse({'status': 'error', 'message': '缺少参数'}, status=400)
        
        # 保存文件到 resource_files 目录
        save_dir = os.path.join(settings.BASE_DIR, '..', 'resource_files')
        if not os.path.exists(save_dir):
            os.makedirs(save_dir)
        save_path = os.path.join(save_dir, file.name)
        with open(save_path, 'wb+') as destination:
            for chunk in file.chunks():
                destination.write(chunk)
        
        # 获取文件大小（以字节为单位）
        file_size = os.path.getsize(save_path)
        
        # 根据文件扩展名确定资源类型
        file_extension = os.path.splitext(file.name)[1].lower()
        resource_type = ''
        if file_extension in ['.doc', '.docx', '.pdf', '.txt']:
            resource_type = 'document'
        elif file_extension in ['.ppt', '.pptx']:
            resource_type = 'presentation'
        elif file_extension in ['.mp4', '.avi', '.mov', '.wmv']:
            resource_type = 'video'
        elif file_extension in ['.mp3', '.wav', '.flac']:
            resource_type = 'audio'
        elif file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
            resource_type = 'image'
        else:
            resource_type = 'other'
                
        # 尝试调用Dify API分析资源，但不影响数据库操作
        try:
            analysis_result = analyze_resource_with_dify(save_path, resource_name)
            dify_doc_id = analysis_result.get('dify_doc_id', 0)
        except Exception as dify_error:
            print(f"Dify分析失败，但继续上传资源: {dify_error}")
            dify_doc_id = 0
        
        # 当前时间字符串
        current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        
        # 使用原生SQL直接将资源信息插入数据库
        with connection.cursor() as cursor:
            # 构建SQL插入语句，使用数据库中实际存在的字段
            insert_sql = """
                INSERT INTO resource (
                    resource_name, resource_type, file_path, file_size, 
                    creator_id, dify_doc_id, description, 
                    create_time, update_time, status
                ) VALUES (
                    %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
                )
            """
            
            values = [
                resource_name, 
                resource_type, 
                save_path, 
                file_size, 
                creator_id, 
                dify_doc_id, 
                f"通过API上传的{resource_type}类型资源",  # 基本描述
                current_time, 
                current_time,
                1  # 状态：正常
            ]
            
            print(f"SQL插入值: {values}")
            
            cursor.execute(insert_sql, values)
            connection.commit()
            
            # 获取最后插入的ID
            cursor.execute("SELECT LAST_INSERT_ID()")
            resource_id = cursor.fetchone()[0]
        
        return JsonResponse({
            'status': 'success',
            'message': '资源上传成功',
            'data': {
                'resource_id': resource_id,
                'resource_name': resource_name,
                'resource_type': resource_type,
                'file_size': file_size,
                'file_path': save_path,
                'create_time': current_time,
                'update_time': current_time,
                'dify_doc_id': dify_doc_id
            }
        })
    except Exception as e:
        print(f"资源上传异常: {e}")
        return JsonResponse({'status': 'error', 'message': str(e)}, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def resource_list(request):
    """
    获取资源列表接口
    @route GET /api/admin/resource/list/
    @description 获取所有资源列表，支持分页和筛选
    @created 2024-06-27
    """
    try:
        # 获取查询参数
        page = int(request.GET.get('page', 1))
        page_size = int(request.GET.get('page_size', 10))
        
        # 使用原生SQL查询，完全避免ORM模型中的字段
        with connection.cursor() as cursor:
            # 查询总数
            cursor.execute("SELECT COUNT(*) FROM resource")
            total = cursor.fetchone()[0]
            
            print(f"数据库中资源总数: {total}")
            
            # 计算分页
            offset = (page - 1) * page_size
            
            # 直接使用表中实际存在的字段
            query = """
                SELECT resource_id, category_id, creator_id, resource_name, 
                       resource_type, file_path, file_size, description, 
                       audit_status, audit_opinion, download_count,
                       create_time, update_time, status, dify_doc_id
                FROM resource
                ORDER BY resource_id DESC
                LIMIT %s OFFSET %s
            """
            
            cursor.execute(query, [page_size, offset])
            
            # 获取所有行数据用于调试
            all_rows = cursor.fetchall()
            
            # 打印原始查询结果
            print(f"查询到 {len(all_rows)} 条资源记录")
            for idx, row in enumerate(all_rows):
                print(f"资源 #{idx+1}:", row)
                
            # 获取列名
            field_names = [i[0] for i in cursor.description]
            print("字段名:", field_names)
            
            resources = []
            for row in all_rows:
                # 将查询结果转换为字典
                resource = dict(zip(field_names, row))
                
                # 处理标准字段 - 使用id而不是resource_id作为前端识别的字段
                resource_data = {
                    'id': int(resource['resource_id']),  # 确保ID是整数类型
                    'resource_id': int(resource['resource_id']),  # 同时保留resource_id字段以兼容
                    'resource_name': resource['resource_name'],
                    'file_path': resource['file_path'],
                    'creator_id': resource['creator_id'],
                    'category_id': resource.get('category_id'),
                    'resource_type': resource.get('resource_type', 'other'),
                    'file_size': resource.get('file_size', 0),
                    'createTime': resource['create_time'].strftime('%Y-%m-%d %H:%M:%S') if resource.get('create_time') else '',
                    'updateTime': resource['update_time'].strftime('%Y-%m-%d %H:%M:%S') if resource.get('update_time') else '',
                    'description': resource.get('description', ''),
                    'audit_status': resource.get('audit_status', 0),
                    'audit_opinion': resource.get('audit_opinion', ''),
                    'download_count': resource.get('download_count', 0),
                    'status': resource.get('status', 1),
                    'dify_doc_id': resource.get('dify_doc_id', 0)
                }
                
                # 添加其他字段
                resource_data['tags'] = []
                resource_data['aiScore'] = 0
                resource_data['aiCategory'] = ''
                resource_data['aiSubCategory'] = ''
                resource_data['aiSubjectArea'] = ''
                resource_data['aiValue'] = ''
                resource_data['aiRecommendUses'] = []
                
                resources.append(resource_data)
            
            print(f"查询到 {len(resources)} 条资源记录")
                
            return JsonResponse({
                'status': 'success',
                'data': {
                    'resources': resources,
                    'total': total,
                    'page': page,
                    'page_size': page_size
                }
            })
    except Exception as e:
        print(f"资源列表获取异常: {e}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取资源列表失败: {str(e)}',
            'data': {
                'resources': [],
                'total': 0,
                'page': page,
                'page_size': page_size
            }
        })

@csrf_exempt
@require_http_methods(["GET", "POST", "DELETE"])
def resource_detail(request, resource_id):
    """
    获取资源详情接口
    @route GET /api/admin/resource/detail/<int:resource_id>/
    @description 获取指定ID资源的详细信息
    @created 2024-06-27
    """
    # 处理DELETE请求 - 删除资源功能
    if request.method == "DELETE" or (request.method == "POST" and request.POST.get('_method') == 'DELETE'):
        try:
            with connection.cursor() as cursor:
                # 检查资源是否存在
                cursor.execute("SELECT resource_id FROM resource WHERE resource_id = %s", [resource_id])
                if not cursor.fetchone():
                    return JsonResponse({
                        'status': 'error',
                        'message': f'资源不存在，ID: {resource_id}'
                    }, status=404)
                
                # 执行删除操作
                cursor.execute("DELETE FROM resource WHERE resource_id = %s", [resource_id])
                
                return JsonResponse({
                    'status': 'success',
                    'message': f'资源已成功删除，ID: {resource_id}'
                })
        except Exception as e:
            print(f"资源删除异常: {e}")
            return JsonResponse({
                'status': 'error',
                'message': f'删除资源失败: {str(e)}'
            }, status=500)
            
    # 处理GET请求 - 获取资源详情
    try:
        # 使用原生SQL查询，避免ORM模型中的不存在字段
        with connection.cursor() as cursor:
            # 直接使用表中实际存在的字段
            query = """
                SELECT resource_id, category_id, creator_id, resource_name, 
                       resource_type, file_path, file_size, description, 
                       audit_status, audit_opinion, download_count,
                       create_time, update_time, status, dify_doc_id
                FROM resource
                WHERE resource_id = %s
            """
            
            cursor.execute(query, [resource_id])
            row = cursor.fetchone()
            
            if not row:
                return JsonResponse({
                    'status': 'error',
                    'message': f'资源不存在，ID: {resource_id}'
                }, status=404)
            
            # 获取列名
            field_names = [i[0] for i in cursor.description]
            
            # 将查询结果转换为字典
            resource = dict(zip(field_names, row))
            
            # 构建响应数据
            resource_data = {
                'id': resource['resource_id'],
                'resource_name': resource['resource_name'],
                'file_path': resource['file_path'],
                'creator_id': resource['creator_id'],
                'category_id': resource.get('category_id'),
                'resource_type': resource.get('resource_type', 'other'),
                'file_size': resource.get('file_size', 0),
                'createTime': resource['create_time'].strftime('%Y-%m-%d %H:%M:%S') if resource.get('create_time') else '',
                'updateTime': resource['update_time'].strftime('%Y-%m-%d %H:%M:%S') if resource.get('update_time') else '',
                'description': resource.get('description', ''),
                'audit_status': resource.get('audit_status', 0),
                'audit_opinion': resource.get('audit_opinion', ''),
                'download_count': resource.get('download_count', 0),
                'status': resource.get('status', 1),
                'dify_doc_id': resource.get('dify_doc_id', 0)
            }
            
            # 由于数据库中没有AI相关字段，给前端提供空默认值
            resource_data['tags'] = []
            resource_data['aiScore'] = 0
            resource_data['aiCategory'] = ''
            resource_data['aiSubCategory'] = ''
            resource_data['aiSubjectArea'] = ''
            resource_data['aiValue'] = ''
            resource_data['aiRecommendUses'] = []
            
            return JsonResponse({
                'status': 'success',
                'data': resource_data
            })
    except Exception as e:
        print(f"资源详情获取异常: {e}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取资源详情失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["DELETE", "POST"])
def resource_delete(request, resource_id):
    """
    删除资源接口
    @route DELETE /api/admin/resource/delete/<int:resource_id>/
    @description 删除指定ID的资源
    @created 2024-06-30
    """
    try:
        with connection.cursor() as cursor:
            # 检查资源是否存在
            cursor.execute("SELECT resource_id FROM resource WHERE resource_id = %s", [resource_id])
            if not cursor.fetchone():
                return JsonResponse({
                    'status': 'error',
                    'message': f'资源不存在，ID: {resource_id}'
                }, status=404)
            
            # 执行删除操作
            cursor.execute("DELETE FROM resource WHERE resource_id = %s", [resource_id])
            
            return JsonResponse({
                'status': 'success',
                'message': f'资源已成功删除，ID: {resource_id}'
            })
    except Exception as e:
        print(f"资源删除异常: {e}")
        return JsonResponse({
            'status': 'error',
            'message': f'删除资源失败: {str(e)}'
        }, status=500)

# 智能交互式帮助系统API接口
@require_http_methods(["POST"])
@csrf_exempt
def dify_chat_completion(request):
    """
    Dify聊天完成接口
    @description 处理非流式对话请求，调用Dify API获取回复
    @return: JsonResponse Dify回复内容
    """
    try:
        data = json.loads(request.body)
        query = data.get('query', '')
        inputs = data.get('inputs', {})
        response_mode = data.get('response_mode', 'blocking')  # stream或blocking
        api_key = data.get('api_key', DIFY_API_KEY)  # 从请求中获取API密钥，如果没有则使用环境变量中的
        server_url = data.get('server_url', DIFY_API_URL)  # 从请求中获取服务器URL，如果没有则使用环境变量中的
        user = data.get('user', 'admin_user')  # 用户标识
        
        logger.info(f"Dify聊天请求: query={query}, inputs={inputs}, response_mode={response_mode}")
        
        # 构建请求头
        headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
        
        # 构建请求体 - 确保包含所有必要字段
        payload = {
            'query': query,
            'inputs': inputs,
            'response_mode': response_mode,
            'user': user
        }
        
        # 处理会话ID
        conversation_id = data.get('conversation_id', '')
        if conversation_id:
            logger.info(f"使用现有会话ID: {conversation_id}")
            
            # 验证是否为有效的UUID格式
            try:
                import uuid
                uuid.UUID(conversation_id)  # 尝试解析，如果无效会抛出异常
                payload['conversation_id'] = conversation_id
            except ValueError:
                logger.warning(f"无效的会话ID格式: {conversation_id}，不使用会话ID")
        
        # 记录完整请求体
        logger.info(f"Dify请求参数: {payload}")
        
        # 直接调用Dify官方API - 使用正确的端点
        dify_url = f"{server_url}/chat-messages"
        logger.info(f"调用Dify API: {dify_url}")
        
        retry_count = 0
        max_retries = 2
        
        while retry_count <= max_retries:
            try:
                response = requests.post(
                    dify_url,
                    headers=headers,
                    json=payload,
                    timeout=30
                )
                
                # 记录详细的响应信息，帮助调试
                logger.info(f"Dify响应: 状态码={response.status_code}, 内容={response.text[:500]}")
                
                if response.status_code == 200:
                    try:
                        result = response.json()
                        
                        # 提取回答内容 - 正确处理不同响应格式
                        answer = ''
                        if 'answer' in result:
                            answer = result['answer']
                        elif 'message' in result and isinstance(result['message'], dict):
                            answer = result['message'].get('answer', '')
                        elif 'event' in result and result['event'] == 'message':
                            answer = result.get('answer', '')
                        
                        # 确保返回会话ID
                        conversation_id = result.get('conversation_id', '')
                        if not conversation_id and result.get('id'):
                            conversation_id = result.get('id') # 有些API版本用id字段
                        
                        # 返回成功响应，包括会话ID
                        return JsonResponse({
                            'status': 'success',
                            'message': '处理成功',
                            'data': {
                                'answer': answer,
                                'conversation_id': conversation_id,
                                'message_id': result.get('message_id', result.get('id', '')),
                                'created_at': result.get('created_at', '')
                            }
                        })
                    except Exception as parse_error:
                        logger.error(f"解析Dify响应JSON出错: {str(parse_error)}", exc_info=True)
                        return JsonResponse({
                            'status': 'error',
                            'message': 'Dify响应解析错误',
                            'error': str(parse_error)
                        }, status=500)
                elif response.status_code == 404:
                    # 特别处理404错误 - 会话可能已过期或无效
                    logger.warning(f"Dify API 404错误，会话可能已过期或无效: {response.text}")
                    
                    # 尝试切换到不带会话ID的请求
                    if 'conversation_id' in payload and retry_count < max_retries:
                        logger.info("尝试不使用会话ID重新请求")
                        payload.pop('conversation_id')
                        retry_count += 1
                        continue
                    
                    # 返回友好的错误信息，包括原始响应
                    return JsonResponse({
                        'status': 'error',
                        'message': 'Dify API错误: 404',
                        'error': '会话可能已过期或无效，请尝试重新开始对话',
                        'original_response': response.text,
                        'query': query,
                        'needReconnect': True
                    }, status=404)
                elif response.status_code == 400:
                    # 可能是请求格式问题，尝试调整格式后重试
                    if retry_count < max_retries:
                        logger.warning(f"Dify API 400错误，尝试调整请求格式: {response.text}")
                        # 确保一些必要字段
                        if 'response_mode' not in payload:
                            payload['response_mode'] = 'blocking'
                        retry_count += 1
                        continue
                        
                    # 返回错误响应
                    return JsonResponse({
                        'status': 'error',
                        'message': f'Dify API错误: 400 - 请求格式错误',
                        'error': response.text,
                        'query': query
                    }, status=400)
                else:
                    # 返回错误响应
                    return JsonResponse({
                        'status': 'error',
                        'message': f'Dify API错误: {response.status_code}',
                        'error': response.text,
                        'query': query
                    }, status=response.status_code)
                    
            except requests.exceptions.RequestException as req_error:
                if retry_count < max_retries:
                    logger.warning(f"请求Dify API出错，准备重试: {str(req_error)}")
                    retry_count += 1
                    time.sleep(1)  # 等待1秒后重试
                    continue
                
                logger.error(f"请求Dify API出错: {str(req_error)}", exc_info=True)
                return JsonResponse({
                    'status': 'error',
                    'message': '请求Dify API失败',
                    'error': str(req_error)
                }, status=500)
                
            # 如果执行到这里，意味着已经处理完请求结果，不再重试
            break
            
    except Exception as e:
        logger.exception(f"处理Dify聊天完成请求出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '处理聊天请求失败',
            'error': str(e)
        }, status=500)

@require_http_methods(["POST"])
@csrf_exempt
def dify_stream_chat(request):
    """
    Dify流式聊天接口
    @description 处理流式对话请求，返回SSE流式响应
    @return: StreamingHttpResponse Dify流式回复
    """
    try:
        data = json.loads(request.body)
        query = data.get('query', '')
        inputs = data.get('inputs', {})
        history = data.get('history', [])
        api_key = data.get('api_key', DIFY_API_KEY)  # 从请求中获取API密钥，如果没有则使用环境变量中的
        server_url = data.get('server_url', DIFY_API_URL)  # 从请求中获取服务器URL，如果没有则使用环境变量中的
        
        logger.info(f"Dify流式聊天请求: query={query}, inputs={inputs}, history={len(history)}条记录")
        
        # 构建请求头
        headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
            'Accept': 'text/event-stream'
        }
        
        # 构建请求体 - 确保包含所有必要字段
        payload = {
            'query': query,
            'inputs': inputs,
            'response_mode': 'streaming',
            'user': data.get('userIdentifier', 'admin_stream_user_' + str(int(time.time())))
        }
        
        # 处理会话ID
        conversation_id = data.get('conversation_id', '')
        if conversation_id:
            payload['conversation_id'] = conversation_id
            
        # 获取流式响应
        dify_url = f"{server_url}/chat-messages"
        logger.info(f"调用Dify流式API: {dify_url}")
        
        # 生成响应流
        def generate_stream():
            try:
                with requests.post(
                    dify_url,
                    headers=headers,
                    json=payload,
                    timeout=60,
                    stream=True
                ) as response:
                    # 检查响应状态
                    if response.status_code != 200:
                        logger.warning(f"流式请求失败，状态码: {response.status_code}")
                        error_message = f'data: {{"error": "流式请求失败，状态码: {response.status_code}"}}\n\n'
                        yield error_message.encode('utf-8')
                        return
                    
                    # 遍历响应流
                    for chunk in response.iter_lines():
                        if chunk:
                            yield chunk + b'\n'
                    
                    # 结束流
                    yield b'data: [DONE]\n\n'
            except Exception as e:
                logger.error(f"流式请求出错: {str(e)}", exc_info=True)
                error_message = f'data: {{"error": "{str(e)}"}}\n\n'
                yield error_message.encode('utf-8')
        
        # 返回流式响应
        return StreamingHttpResponse(
            generate_stream(),
            content_type='text/event-stream'
        )
        
    except Exception as e:
        logger.exception(f"处理Dify流式聊天请求出错: {str(e)}")
        
        # 构建错误响应
        def error_stream():
            error_message = f'data: {{"error": "{str(e)}"}}\n\n'
            yield error_message.encode('utf-8')
        
        return StreamingHttpResponse(
            error_stream(),
            content_type='text/event-stream',
            status=500
        )

@require_http_methods(["GET"])
def dify_get_apps(request):
    """
    获取Dify应用列表
    @description 获取所有可用的Dify应用
    @return: JsonResponse 应用列表
    """
    try:
        # 在实际实现中，你应该调用Dify API获取应用列表
        # 这里我们返回一个模拟的应用列表
        apps = [
            {
                'id': os.environ.get('DIFY_ASSISTANT_APP_ID', 'assistant-app-id'),
                'name': '智能交互式帮助系统',
                'description': '为用户提供AI教学管理平台的使用指导和问题解答',
                'icon': '🤖',
                'created_at': '2024-06-29T10:00:00Z'
            },
            {
                'id': os.environ.get('DIFY_TEACHING_APP_ID', 'teaching-app-id'),
                'name': '教学助手',
                'description': '辅助教师进行教学活动的AI助手',
                'icon': '📚',
                'created_at': '2024-06-28T14:30:00Z'
            }
        ]
        
        return JsonResponse({
            'status': 'success',
            'message': '获取应用列表成功',
            'data': apps
        })
    
    except Exception as e:
        logger.exception(f"获取Dify应用列表错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取应用列表失败',
            'error': str(e)
        }, status=500)

@require_http_methods(["GET"])
def dify_frequent_questions(request):
    """
    获取帮助系统常见问题
    @description 返回智能帮助系统的常见问题列表
    @return: JsonResponse 常见问题列表
    """
    try:
        # 在实际实现中，你可能会从数据库加载这些问题
        # 这里我们返回一个预定义的问题列表
        frequent_questions = [
            {
                'question': '如何重置用户密码？',
                'answer': '管理员可以在「用户管理」页面，找到对应用户，点击「重置密码」按钮进行操作。系统会生成一个临时密码并发送到用户的注册邮箱。'
            },
            {
                'question': '如何批量导入学生信息？',
                'answer': '在「学生管理」页面，点击右上角的「批量导入」按钮，下载模板，填写后上传即可。系统支持Excel和CSV格式的文件导入。'
            },
            {
                'question': '如何分析教学质量？',
                'answer': '进入「教学质量智能评估系统」，选择学院和学期，点击「生成评估报告」按钮。系统会自动分析教学数据并生成多维度的质量报告。'
            },
            {
                'question': '如何导出数据报表？',
                'answer': '在各个分析页面，点击右上角的「导出报告」按钮，选择导出格式（PDF, Excel, Word）即可。导出的报表包含所有图表和分析结果。'
            },
            {
                'question': '如何设置学期时间？',
                'answer': '进入「系统设置」-「学期管理」，点击「添加学期」，设置学期名称、开始日期和结束日期，保存即可。'
            },
            {
                'question': '如何添加新教师？',
                'answer': '添加新教师的步骤：\n1. 进入「用户管理」-「教师管理」页面\n2. 点击右上角「添加教师」按钮\n3. 填写教师基本信息，包括姓名、工号、学院、职称等\n4. 上传教师照片（可选）\n5. 点击「保存」完成添加'
            },
            {
                'question': '如何查看教学质量报告？',
                'answer': '查看教学质量报告：\n1. 进入「教学质量智能评估系统」\n2. 选择要查看的学院和学期\n3. 点击「生成评估报告」\n4. 系统会自动生成包含多个维度的教学质量分析报告'
            },
            {
                'question': '如何使用AI决策系统？',
                'answer': 'AI决策系统使用指南：\n1. 进入「AI辅助决策分析系统」\n2. 选择数据时间范围\n3. 在智能数据查询框中输入自然语言问题\n4. 查看异常模式识别和预测分析结果\n5. 根据AI建议进行决策调整'
            }
        ]
        
        return JsonResponse({
            'status': 'success',
            'message': '获取常见问题成功',
            'data': frequent_questions
        })
    
    except Exception as e:
        logger.exception(f"获取常见问题列表错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取常见问题失败',
            'error': str(e)
        }, status=500)

@require_http_methods(["GET"])
def dify_context_questions(request):
    """
    获取上下文感知问题
    @description 根据当前上下文返回相关的问题列表
    @param context: 当前用户所在的上下文（如页面名称）
    @return: JsonResponse 上下文相关问题列表
    """
    try:
        # 获取上下文参数，如果没有，默认为"管理员主页"
        context = request.GET.get('context', '管理员主页')
        logger.info(f"获取上下文问题, context={context}")
        
        # 根据不同上下文返回不同问题
        context_questions = []
        
        if context == '管理员主页':
            context_questions = [
                {'question': '如何查看系统整体运行状况？'},
                {'question': '如何查看用户活跃度统计？'},
                {'question': '如何访问快速功能入口？'},
                {'question': '如何查看待办事项？'}
            ]
        elif context == '用户管理':
            context_questions = [
                {'question': '如何添加新用户？'},
                {'question': '如何批量导入用户？'},
                {'question': '如何修改用户权限？'},
                {'question': '如何重置用户密码？'}
            ]
        elif context == '教学质量':
            context_questions = [
                {'question': '教学质量评估系统的指标是如何计算的？'},
                {'question': '如何查看历史评估报告？'},
                {'question': '如何导出评估结果？'},
                {'question': '如何设置评估标准？'}
            ]
        elif context == 'AI决策系统':
            context_questions = [
                {'question': '如何使用AI辅助决策分析系统？'},
                {'question': '如何理解决策建议的依据？'},
                {'question': '如何使用自然语言查询教学数据？'},
                {'question': '如何查看历史分析结果？'}
            ]
        else:
            # 默认问题
            context_questions = [
                {'question': '如何使用AI辅助决策分析系统？'},
                {'question': '教学质量评估系统的指标是如何计算的？'},
                {'question': '如何查看教师的教学风格分析？'},
                {'question': '如何使用自然语言查询教学数据？'}
            ]
        
        return JsonResponse({
            'status': 'success',
            'message': '获取上下文问题成功',
            'data': context_questions
        })
    
    except Exception as e:
        logger.exception(f"获取上下文问题错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取上下文问题失败',
            'error': str(e)
        }, status=500)

@require_http_methods(["POST"])
@csrf_exempt
def dify_feedback(request):
    """
    提交回答反馈
    @description 提交用户对AI回答的反馈
    @return: JsonResponse 反馈处理结果
    """
    try:
        data = json.loads(request.body)
        message_id = data.get('messageId', '')
        is_helpful = data.get('isHelpful', False)
        feedback_text = data.get('feedback', '')
        
        logger.info(f"接收到反馈: messageId={message_id}, isHelpful={is_helpful}, feedback={feedback_text}")
        
        # 在实际实现中，你应该将反馈保存到数据库或发送到Dify
        # 这里我们只记录日志
        
        # 如果有Dify API可用于反馈，可以调用它
        if DIFY_API_KEY and message_id:
            # 构建请求头
            headers = {
                'Authorization': f'Bearer {DIFY_API_KEY}',
                'Content-Type': 'application/json'
            }
            
            # 构建请求体
            payload = {
                'rating': 'like' if is_helpful else 'dislike',
                'user': data.get('user', 'admin'),
            }
            
            # 如果有文本反馈，添加到请求
            if feedback_text:
                payload['text'] = feedback_text
            
            # 调用Dify反馈API
            # 实际的Dify反馈API路径可能需要调整
            feedback_url = f"{DIFY_API_URL}/messages/{message_id}/feedbacks"
            
            try:
                response = requests.post(
                    feedback_url,
                    headers=headers,
                    json=payload,
                    timeout=10
                )
                
                if response.status_code == 200:
                    logger.info(f"反馈成功发送到Dify: {response.json()}")
                else:
                    logger.warning(f"向Dify发送反馈失败: {response.status_code}, {response.text}")
            except Exception as api_error:
                logger.error(f"调用Dify反馈API错误: {str(api_error)}")
        
        return JsonResponse({
            'status': 'success',
            'message': '反馈提交成功，感谢您的反馈！'
        })
    
    except Exception as e:
        logger.exception(f"处理反馈提交错误: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '反馈提交失败',
            'error': str(e)
        }, status=500)

# 添加直接测试Dify API连接的函数
@require_http_methods(["GET"])
def test_dify_connection(request):
    """
    测试Dify API连接
    @description 直接测试与Dify API的连接，返回连接状态
    @return: JsonResponse 连接测试结果
    """
    try:
        # 测试不同的API端点
        endpoints = [
            '/chat-messages',  # 正确的端点
            '/completions',
            '/messages',
            '/models'
        ]
        
        results = {}
        
        for endpoint in endpoints:
            try:
                # 构建请求头
                headers = {
                    'Authorization': f'Bearer {DIFY_API_KEY}',
                    'Content-Type': 'application/json'
                }
                
                # 尝试使用GET方法访问
                test_url = f"{DIFY_API_URL}{endpoint}"
                logger.info(f"测试Dify端点: {test_url}")
                
                response = requests.get(
                    test_url,
                    headers=headers,
                    timeout=10
                )
                
                results[endpoint] = {
                    'status_code': response.status_code,
                    'response': response.text[:200] if response.text else 'No response'
                }
                
                logger.info(f"端点 {endpoint} 测试结果: {response.status_code}")
                
            except Exception as e:
                results[endpoint] = {
                    'error': str(e)
                }
                logger.error(f"测试端点 {endpoint} 出错: {str(e)}")
        
        # 测试最简单的聊天请求
        try:
            chat_url = f"{DIFY_API_URL}/chat-messages"
            logger.info(f"测试简单聊天请求: {chat_url}")
            
            headers = {
                'Authorization': f'Bearer {DIFY_API_KEY}',
                'Content-Type': 'application/json'
            }
            
            test_payload = {
                'query': '你好，请简单介绍一下你自己',
                'inputs': {},
                'response_mode': 'blocking',
                'user': 'test_user'
            }
            
            chat_response = requests.post(
                chat_url,
                headers=headers,
                json=test_payload,
                timeout=30
            )
            
            results['simple_chat_test'] = {
                'status_code': chat_response.status_code,
                'response': chat_response.text[:300] if chat_response.text else 'No response'
            }
            
            logger.info(f"简单聊天测试结果: {chat_response.status_code}")
            
        except Exception as e:
            results['simple_chat_test'] = {
                'error': str(e)
            }
            logger.error(f"测试简单聊天请求出错: {str(e)}")
        
        return JsonResponse({
            'status': 'success',
            'message': 'Dify API连接测试完成',
            'data': results,
            'api_url': DIFY_API_URL,
            'api_key_prefix': DIFY_API_KEY[:10] + '...' if DIFY_API_KEY else 'Not Set'
        })
        
    except Exception as e:
        logger.exception(f"测试Dify API连接时出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '测试Dify API连接失败',
            'error': str(e)
        }, status=500)

# 最后一个函数后面添加新的CORS代理函数
@require_http_methods(["POST", "GET", "OPTIONS"])
@csrf_exempt
def dify_cors_proxy(request):
    """
    Dify API CORS代理
    @description 为前端提供一个代理，绕过CORS限制直接访问Dify API
    @return: JsonResponse 代理的Dify响应
    """
    try:
        # 处理OPTIONS请求
        if request.method == "OPTIONS":
            response = JsonResponse({'status': 'success'})
            response["Access-Control-Allow-Origin"] = "*"
            response["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
            response["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
            return response
            
        # 获取请求路径
        path = request.GET.get('path', 'chat-completions')
        
        # 构建目标URL
        target_url = f"{DIFY_API_URL}/{path}"
        logger.info(f"CORS代理请求: {request.method} {target_url}")
        
        # 构建请求头
        headers = {}
        for key, value in request.headers.items():
            if key.lower() not in ['host', 'content-length']:
                headers[key] = value
                
        # 确保有Authorization头，如果请求中没有提供，使用默认值
        if 'Authorization' not in headers:
            headers['Authorization'] = f'Bearer {DIFY_API_KEY}'
        
        # 处理GET请求
        if request.method == "GET":
            response = requests.get(
                target_url,
                headers=headers,
                params=request.GET.dict(),
                timeout=30
            )
        # 处理POST请求
        elif request.method == "POST":
            # 获取请求体
            if request.content_type and 'application/json' in request.content_type:
                data = json.loads(request.body) if request.body else {}
            else:
                data = request.POST.dict()
                
            response = requests.post(
                target_url,
                headers=headers,
                json=data,
                timeout=30
            )
        else:
            return JsonResponse({'status': 'error', 'message': f'不支持的HTTP方法: {request.method}'}, status=400)
        
        # 返回响应
        logger.info(f"CORS代理响应: {response.status_code}")
        
        # 构建Django响应
        django_response = JsonResponse(response.json() if response.text else {}, safe=False, status=response.status_code)
        
        # 添加CORS头
        django_response["Access-Control-Allow-Origin"] = "*"
        django_response["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
        django_response["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
        
        return django_response
        
    except Exception as e:
        logger.exception(f"CORS代理错误: {str(e)}")
        response = JsonResponse({
            'status': 'error',
            'message': f'CORS代理错误: {str(e)}'
        }, status=500)
        response["Access-Control-Allow-Origin"] = "*"
        return response

# AI决策系统相关接口 - 决策建议API
@csrf_exempt
@require_http_methods(["GET"])
def ai_recommendations(request, category):
    """
    获取AI决策建议
    @param request: HTTP请求
    @param category: 建议类别 (curriculum/resource/teaching/evaluation)
    @return: JSON 建议列表
    """
    try:
        # 获取查询参数
        time_range = request.GET.get('timeRange', 'semester')
        college_id = request.GET.get('collegeId', None)
        
        logger.info(f"获取决策建议: category={category}, timeRange={time_range}, collegeId={college_id}")
        
        # 根据类别返回不同的建议
        recommendations = []
        
        if category == 'curriculum':
            recommendations = [
                {
                    'id': 'curr_1',
                    'category': 'curriculum',
                    'title': '增加实践课程比例',
                    'content': '根据学生学习行为分析，建议在计算机科学专业增加实践课程比例，从当前的30%提高到40%，以提升学生动手能力和项目经验。',
                    'confidence': 85,
                    'data': {
                        'current_ratio': 30,
                        'suggested_ratio': 40,
                        'similar_schools': ['清华大学', '浙江大学', '上海交通大学']
                    }
                },
                {
                    'id': 'curr_2',
                    'category': 'curriculum',
                    'title': '调整高数课程进度',
                    'content': '数据显示大一学生在高等数学第一学期的失败率较高，建议将课程内容分散到更长时间段，并增加阶段性辅导。',
                    'confidence': 78,
                    'data': {
                        'current_failure_rate': 32,
                        'expected_improvement': 15,
                        'implementation_difficulty': 'medium'
                    }
                },
                {
                    'id': 'curr_3',
                    'category': 'curriculum',
                    'title': '引入跨学科课程',
                    'content': '当前就业市场对复合型人才需求增加，建议在专业课程中增加跨学科内容，如计算机专业增加商业和设计思维课程。',
                    'confidence': 83,
                    'data': {
                        'market_demand_increase': 45,
                        'suggested_courses': ['商业模型', '用户体验设计', '创新创业']
                    }
                }
            ]
        elif category == 'resource':
            recommendations = [
                {
                    'id': 'res_1',
                    'category': 'resource',
                    'title': '扩充机器学习资源库',
                    'content': '人工智能相关课程的资源访问量增长了75%，建议扩充机器学习、深度学习等相关教学资源，尤其是实践项目案例。',
                    'confidence': 92,
                    'data': {
                        'access_increase': 75,
                        'most_requested': ['神经网络案例', '计算机视觉实例', 'NLP入门']
                    }
                },
                {
                    'id': 'res_2',
                    'category': 'resource',
                    'title': '优化移动端资源访问',
                    'content': '超过65%的学生通过移动设备访问教学资源，建议优化资源平台的移动端适配性，提升用户体验。',
                    'confidence': 87,
                    'data': {
                        'mobile_access_ratio': 65,
                        'desktop_access_ratio': 35,
                        'bounce_rate_mobile': 42
                    }
                },
                {
                    'id': 'res_3',
                    'category': 'resource',
                    'title': '增加交互式学习内容',
                    'content': '分析显示，具有交互性的学习资源完成率高出传统资源25%，建议增加模拟实验、互动问答等教学内容。',
                    'confidence': 81,
                    'data': {
                        'completion_rate_interactive': 78,
                        'completion_rate_traditional': 53,
                        'student_satisfaction_increase': 31
                    }
                }
            ]
        elif category == 'teaching':
            recommendations = [
                {
                    'id': 'teach_1',
                    'category': 'teaching',
                    'title': '采用混合式教学模式',
                    'content': '分析表明，混合在线和线下教学的课程学生参与度提高了23%，建议更多课程采用混合式教学模式。',
                    'confidence': 89,
                    'data': {
                        'engagement_increase': 23,
                        'successful_courses': ['数据结构', '操作系统', '市场营销']
                    }
                },
                {
                    'id': 'teach_2',
                    'category': 'teaching',
                    'title': '增加小组协作项目',
                    'content': '有小组协作项目的课程学生满意度平均高出17个百分点，建议在专业核心课程中增加团队协作环节。',
                    'confidence': 82,
                    'data': {
                        'satisfaction_increase': 17,
                        'skill_development': ['沟通能力', '团队协作', '项目管理']
                    }
                },
                {
                    'id': 'teach_3',
                    'category': 'teaching',
                    'title': '引入实时反馈系统',
                    'content': '使用课堂实时反馈系统的教师教学评价提高了15%，建议在更多课程中采用数字化反馈工具。',
                    'confidence': 78,
                    'data': {
                        'teacher_rating_increase': 15,
                        'student_confusion_decrease': 28,
                        'recommended_tools': ['班班通', '雨课堂', '智慧教室系统']
                    }
                }
            ]
        elif category == 'evaluation':
            recommendations = [
                {
                    'id': 'eval_1',
                    'category': 'evaluation',
                    'title': '多维度评估体系',
                    'content': '单一考试评估方式导致学生学习行为短期化，建议实施包含过程考核、项目评估、同伴评价等多维度评估体系。',
                    'confidence': 91,
                    'data': {
                        'current_exam_weight': 70,
                        'recommended_weights': {
                            'final_exam': 40,
                            'projects': 30,
                            'participation': 15,
                            'peer_review': 15
                        }
                    }
                },
                {
                    'id': 'eval_2',
                    'category': 'evaluation',
                    'title': '引入形成性评估',
                    'content': '实施形成性评估的课程中，学生学习投入时间增加了31%，建议在更多课程中引入阶段性形成性评估。',
                    'confidence': 84,
                    'data': {
                        'learning_time_increase': 31,
                        'recommended_frequency': '每章节一次',
                        'implementation_cost': 'low to medium'
                    }
                },
                {
                    'id': 'eval_3',
                    'category': 'evaluation',
                    'title': '基于能力的评估模型',
                    'content': '基于能力评估的课程与行业需求对接更紧密，毕业生就业率高出传统评估课程12%，建议推广能力导向评估。',
                    'confidence': 88,
                    'data': {
                        'employment_rate_increase': 12,
                        'industry_satisfaction': 'high',
                        'key_capabilities': ['问题解决', '批判思维', '创新能力']
                    }
                }
            ]
        else:
            # 未知建议类别
            return JsonResponse({
                'status': 'error',
                'message': f'未支持的建议类别: {category}',
                'supported_categories': ['curriculum', 'resource', 'teaching', 'evaluation']
            }, status=400)
        
        # 根据学院ID筛选建议
        if college_id:
            # 实际应用中，这里应该根据学院ID定制建议
            # 这里只是简单模拟
            pass
            
        # 返回建议列表
        return JsonResponse({
            'status': 'success',
            'message': '获取决策建议成功',
            'data': recommendations
        })
            
    except Exception as e:
        logger.exception(f"获取决策建议出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取决策建议失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 建议反馈API
@csrf_exempt
@require_http_methods(["POST"])
def ai_recommendation_feedback(request):
    """
    提交用户对建议的反馈
    @param request: HTTP请求
    @return: JSON 反馈处理结果
    """
    try:
        # 解析请求体
        data = json.loads(request.body)
        recommendation_id = data.get('recommendationId')
        action = data.get('action')
        category = data.get('category')
        feedback = data.get('feedback', '')
        
        logger.info(f"提交建议反馈: id={recommendation_id}, action={action}, category={category}")
        
        # 验证必要参数
        if not recommendation_id or not action or not category:
            return JsonResponse({
                'status': 'error',
                'message': '缺少必要参数'
            }, status=400)
        
        # 验证操作类型
        if action not in ['adopt', 'ignore']:
            return JsonResponse({
                'status': 'error',
                'message': '不支持的操作类型',
                'supported_actions': ['adopt', 'ignore']
            }, status=400)
        
        # 在实际应用中，这里应该将反馈保存到数据库
        # 这里只是简单模拟处理结果
        
        # 返回处理结果
        return JsonResponse({
            'status': 'success',
            'message': f'反馈提交成功，已{action == "adopt" and "采纳" or "忽略"}建议',
            'data': {
                'id': recommendation_id,
                'action': action,
                'category': category,
                'processed_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }
        })
            
    except json.JSONDecodeError:
        logger.error("请求体JSON解析错误")
        return JsonResponse({
            'status': 'error',
            'message': '请求体格式错误，应为JSON格式'
        }, status=400)
    except Exception as e:
        logger.exception(f"处理建议反馈出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '处理建议反馈失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 自然语言查询API
@csrf_exempt
@require_http_methods(["POST"])
def ai_nl_query(request):
    """
    处理自然语言查询教学数据
    @param request: HTTP请求
    @return: JSON 查询结果
    """
    try:
        # 解析请求体
        data = json.loads(request.body)
        query = data.get('query', '')
        time_range = data.get('timeRange', 'semester')
        context = data.get('context', '')
        api_key = data.get('api_key', DIFY_API_KEY)
        server_url = data.get('server_url', DIFY_API_URL)
        
        logger.info(f"自然语言查询: query={query}, timeRange={time_range}, context={context}")
        
        # 验证查询参数
        if not query:
            return JsonResponse({
                'status': 'error',
                'message': '查询内容不能为空'
            }, status=400)
        
        # 调用Dify API进行自然语言处理
        # 构建请求头
        headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
        
        # 构建请求体
        payload = {
            'query': query,
            'inputs': {
                'timeRange': time_range,
                'context': context or '教育数据分析'
            },
            'response_mode': 'blocking',
            'user': f'admin_nl_query_{int(time.time())}'
        }
        
        # 调用Dify API
        try:
            response = requests.post(
                f"{server_url}/chat-messages",
                headers=headers,
                json=payload,
                timeout=30
            )
            
            # 检查响应状态
            if response.status_code == 200:
                result = response.json()
                
                # 提取回答内容
                answer = ''
                if 'answer' in result:
                    answer = result['answer']
                elif 'message' in result and isinstance(result['message'], dict):
                    answer = result['message'].get('answer', '')
                elif 'event' in result and result['event'] == 'message':
                    answer = result.get('answer', '')
                
                # 返回处理结果
                return JsonResponse({
                    'status': 'success',
                    'message': '查询处理成功',
                    'data': {
                        'result': answer,
                        'query': query,
                        'conversation_id': result.get('conversation_id', ''),
                        'message_id': result.get('message_id', result.get('id', ''))
                    }
                })
            else:
                # 处理错误响应
                logger.error(f"Dify API错误: {response.status_code}, {response.text}")
                
                # 生成一个备用响应，避免完全失败
                fallback_answer = generate_fallback_answer(query, time_range)
                
                return JsonResponse({
                    'status': 'warning',
                    'message': f'AI服务返回错误，使用备用回答',
                    'data': {
                        'result': fallback_answer,
                        'query': query,
                        'is_fallback': True
                    },
                    'error': {
                        'status_code': response.status_code,
                        'detail': response.text
                    }
                })
                
        except requests.exceptions.RequestException as e:
            logger.error(f"调用Dify API出错: {str(e)}")
            
            # 生成一个备用响应，避免完全失败
            fallback_answer = generate_fallback_answer(query, time_range)
            
            return JsonResponse({
                'status': 'warning',
                'message': 'AI服务暂时不可用，使用备用回答',
                'data': {
                    'result': fallback_answer,
                    'query': query,
                    'is_fallback': True
                },
                'error': str(e)
            })
            
    except json.JSONDecodeError:
        logger.error("请求体JSON解析错误")
        return JsonResponse({
            'status': 'error',
            'message': '请求体格式错误，应为JSON格式'
        }, status=400)
    except Exception as e:
        logger.exception(f"处理自然语言查询出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '处理查询失败',
            'error': str(e)
        }, status=500)

# 生成备用回答函数
def generate_fallback_answer(query, time_range):
    """
    当AI服务不可用时生成备用回答
    @param query: 用户查询
    @param time_range: 时间范围
    @return: string 备用回答
    """
    # 基于关键词的简单匹配逻辑
    query_lower = query.lower()
    
    if '成绩' in query_lower or '分数' in query_lower:
        return f"{time_range}内，全校平均成绩为82.5分，比上期提高1.2分。计算机科学学院平均分最高，达到86.3分，文学院进步最大，提升3.1分。"
    
    elif '出勤' in query_lower or '考勤' in query_lower:
        return f"{time_range}内，全校平均出勤率为92.7%，工学院出勤率最高，达到95.3%，经济学院出勤率最低，为88.2%。"
    
    elif '资源' in query_lower or '教材' in query_lower:
        return f"{time_range}内，学习资源平台访问量增长15%，电子教材下载量增长23%，视频资源观看时长增长31%。"
    
    elif '教师' in query_lower or '老师' in query_lower:
        return f"{time_range}内，教师平均评分为4.6/5，其中30%的教师评分超过4.8，5%的教师评分低于4.0。"
    
    elif '专业' in query_lower or '学院' in query_lower:
        return f"{time_range}内，计算机科学学院和人工智能学院学生成绩和参与度最高，医学院教学满意度最高，达到96%。"
    
    else:
        return f"在{time_range}内，教学整体运行良好，学生平均成绩82.5分，教师满意度88%，资源使用率75%。详细数据请查看各模块报告。"

# AI决策系统相关接口 - 连接测试API
@csrf_exempt
@require_http_methods(["POST"])
def test_decision_connection(request):
    """
    测试AI决策系统连接
    @param request: HTTP请求
    @return: JSON 连接测试结果
    """
    try:
        # 解析请求体
        data = json.loads(request.body)
        api_key = data.get('api_key', DIFY_API_KEY)
        server_url = data.get('server_url', DIFY_API_URL)
        
        logger.info(f"测试AI决策系统连接: server_url={server_url}")
        
        # 测试连接
        headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
        
        # 简单的测试请求
        test_payload = {
            'query': '测试连接',
            'response_mode': 'blocking',
            'user': f'test_connection_{int(time.time())}'
        }
        
        # 发送请求
        response = requests.post(
            f"{server_url}/chat-messages",
            headers=headers,
            json=test_payload,
            timeout=10
        )
        
        # 检查响应状态
        if response.status_code == 200:
            # 连接成功
            return JsonResponse({
                'status': 'success',
                'message': 'AI决策系统连接正常',
                'data': {
                    'api_url': server_url,
                    'response_time': response.elapsed.total_seconds(),
                    'status_code': response.status_code
                }
            })
        else:
            # 连接失败
            return JsonResponse({
                'status': 'error',
                'message': 'AI决策系统连接异常',
                'error': {
                    'status_code': response.status_code,
                    'response': response.text[:200] if response.text else 'No response',
                    'api_url': server_url
                }
            }, status=500)
            
    except json.JSONDecodeError:
        logger.error("请求体JSON解析错误")
        return JsonResponse({
            'status': 'error',
            'message': '请求体格式错误，应为JSON格式'
        }, status=400)
    except requests.exceptions.RequestException as e:
        logger.error(f"测试连接请求异常: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': 'AI决策系统连接失败',
            'error': str(e)
        }, status=500)
    except Exception as e:
        logger.exception(f"测试AI决策系统连接出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '测试连接失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 教学数据分析API
@csrf_exempt
@require_http_methods(["POST"])
def ai_analyze_teaching_data(request):
    """
    使用AI分析教学数据
    @param request: HTTP请求
    @return: JSON 分析结果
    """
    try:
        # 解析请求体
        data = json.loads(request.body)
        analysis_type = data.get('analysisType', '')
        analysis_data = data.get('data', {})
        
        logger.info(f"分析教学数据: type={analysis_type}")
        
        # 验证分析类型
        if not analysis_type:
            return JsonResponse({
                'status': 'error',
                'message': '分析类型不能为空'
            }, status=400)
        
        # 根据分析类型进行不同的处理
        if analysis_type == 'student_performance':
            # 学生表现分析
            result = {
                'summary': '学生整体表现良好，平均成绩82.5分，优秀率35%，不及格率5%',
                'trends': {
                    'average_scores': [78.2, 80.1, 82.5],
                    'excellence_rate': [30, 32, 35],
                    'fail_rate': [8, 6, 5]
                },
                'recommendations': [
                    '关注不及格学生，提供针对性辅导',
                    '鼓励优秀学生参与学科竞赛和研究项目',
                    '优化教学内容，增加实践环节'
                ]
            }
        elif analysis_type == 'teaching_quality':
            # 教学质量分析
            result = {
                'summary': '教学质量评价总体良好，平均评分4.6/5，满意度88%',
                'strengths': ['教师专业素养', '课程内容设计', '学生互动'],
                'weaknesses': ['答疑效率', '作业反馈时间', '教学资源多样性'],
                'recommendations': [
                    '优化线上答疑系统，提高响应速度',
                    '增加教学助理，缩短作业反馈周期',
                    '丰富教学资源形式，增加多媒体和互动内容'
                ]
            }
        elif analysis_type == 'resource_usage':
            # 资源使用分析
            result = {
                'summary': '教学资源使用率75%，视频资源最受欢迎，电子书使用率偏低',
                'resource_usage': {
                    'video': 85,
                    'practice': 78,
                    'document': 65,
                    'ebook': 52
                },
                'peak_times': ['星期一上午', '星期三下午', '星期日晚上'],
                'recommendations': [
                    '优化电子书阅读体验，增加互动功能',
                    '根据使用高峰期增加服务器资源',
                    '根据学生反馈调整视频内容长度和节奏'
                ]
            }
        else:
            # 未知分析类型
            return JsonResponse({
                'status': 'error',
                'message': f'未支持的分析类型: {analysis_type}',
                'supported_types': ['student_performance', 'teaching_quality', 'resource_usage']
            }, status=400)
        
        # 返回分析结果
        return JsonResponse({
            'status': 'success',
            'message': '分析教学数据成功',
            'data': result
        })
            
    except json.JSONDecodeError:
        logger.error("请求体JSON解析错误")
        return JsonResponse({
            'status': 'error',
            'message': '请求体格式错误，应为JSON格式'
        }, status=400)
    except Exception as e:
        logger.exception(f"分析教学数据出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '分析教学数据失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 教学质量指标API
@csrf_exempt
@require_http_methods(["GET"])
def ai_teaching_quality(request):
    """
    获取学院教学质量指标
    @param request: HTTP请求
    @return: JSON 教学质量指标数据
    """
    try:
        # 获取查询参数
        time_range = request.GET.get('timeRange', 'semester')
        college_id = request.GET.get('collegeId', None)
        
        logger.info(f"获取教学质量指标: timeRange={time_range}, collegeId={college_id}")
        
        # 模拟数据 - 实际应用中应该从数据库获取
        colleges = [
            {
                'id': 1,
                'name': '计算机科学学院',
                'metrics': {
                    'teaching_satisfaction': 92,
                    'student_pass_rate': 95,
                    'resource_satisfaction': 88,
                    'teacher_evaluation': 4.7,
                    'curriculum_rationality': 4.5,
                    'practice_opportunity': 4.8
                }
            },
            {
                'id': 2,
                'name': '工学院',
                'metrics': {
                    'teaching_satisfaction': 90,
                    'student_pass_rate': 93,
                    'resource_satisfaction': 85,
                    'teacher_evaluation': 4.6,
                    'curriculum_rationality': 4.3,
                    'practice_opportunity': 4.9
                }
            },
            {
                'id': 3,
                'name': '经济学院',
                'metrics': {
                    'teaching_satisfaction': 88,
                    'student_pass_rate': 91,
                    'resource_satisfaction': 82,
                    'teacher_evaluation': 4.5,
                    'curriculum_rationality': 4.4,
                    'practice_opportunity': 4.2
                }
            },
            {
                'id': 4,
                'name': '理学院',
                'metrics': {
                    'teaching_satisfaction': 89,
                    'student_pass_rate': 94,
                    'resource_satisfaction': 86,
                    'teacher_evaluation': 4.6,
                    'curriculum_rationality': 4.5,
                    'practice_opportunity': 4.3
                }
            },
            {
                'id': 5,
                'name': '文学院',
                'metrics': {
                    'teaching_satisfaction': 91,
                    'student_pass_rate': 96,
                    'resource_satisfaction': 87,
                    'teacher_evaluation': 4.8,
                    'curriculum_rationality': 4.6,
                    'practice_opportunity': 4.0
                }
            }
        ]
        
        # 如果指定了学院ID，则只返回该学院的数据
        if college_id:
            try:
                college_id = int(college_id)
                filtered_colleges = [c for c in colleges if c['id'] == college_id]
                if filtered_colleges:
                    colleges = filtered_colleges
                else:
                    return JsonResponse({
                        'status': 'error',
                        'message': f'未找到ID为{college_id}的学院'
                    }, status=404)
            except ValueError:
                return JsonResponse({
                    'status': 'error',
                    'message': '学院ID必须是整数'
                }, status=400)
        
        # 计算全校平均指标
        if not college_id:
            avg_metrics = {
                'teaching_satisfaction': sum(c['metrics']['teaching_satisfaction'] for c in colleges) / len(colleges),
                'student_pass_rate': sum(c['metrics']['student_pass_rate'] for c in colleges) / len(colleges),
                'resource_satisfaction': sum(c['metrics']['resource_satisfaction'] for c in colleges) / len(colleges),
                'teacher_evaluation': sum(c['metrics']['teacher_evaluation'] for c in colleges) / len(colleges),
                'curriculum_rationality': sum(c['metrics']['curriculum_rationality'] for c in colleges) / len(colleges),
                'practice_opportunity': sum(c['metrics']['practice_opportunity'] for c in colleges) / len(colleges)
            }
            
            # 添加全校平均数据
            colleges.append({
                'id': 0,
                'name': '全校平均',
                'metrics': avg_metrics
            })
        
        # 返回质量指标数据
        return JsonResponse({
            'status': 'success',
            'message': '获取教学质量指标成功',
            'data': {
                'colleges': colleges,
                'metrics_description': {
                    'teaching_satisfaction': '教学满意度(%)',
                    'student_pass_rate': '学生通过率(%)',
                    'resource_satisfaction': '资源满意度(%)',
                    'teacher_evaluation': '教师评价(1-5分)',
                    'curriculum_rationality': '课程合理性(1-5分)',
                    'practice_opportunity': '实践机会(1-5分)'
                }
            }
        })
            
    except Exception as e:
        logger.exception(f"获取教学质量指标出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取教学质量指标失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 资源优化API
@csrf_exempt
@require_http_methods(["POST"])
def ai_resource_optimization(request):
    """
    生成教育资源优化方案
    @param request: HTTP请求
    @return: JSON 资源优化方案
    """
    try:
        # 解析请求体
        data = json.loads(request.body)
        resource_type = data.get('resourceType', '')
        college_id = data.get('collegeId')
        optimization_target = data.get('optimizationTarget', 'efficiency')
        
        logger.info(f"生成资源优化方案: type={resource_type}, target={optimization_target}")
        
        # 验证资源类型
        if not resource_type:
            return JsonResponse({
                'status': 'error',
                'message': '资源类型不能为空'
            }, status=400)
        
        # 根据资源类型和优化目标生成不同的方案
        if resource_type == 'classroom':
            # 教室资源优化
            result = {
                'summary': '教室使用效率可提升18%，通过优化排课算法和调整使用时段',
                'current_status': {
                    'usage_rate': 72,
                    'peak_time_congestion': 85,
                    'off_peak_vacancy': 35
                },
                'optimization_plan': {
                    'steps': [
                        '实施智能排课系统，基于历史数据和课程特性自动分配教室',
                        '调整部分非核心课程到非高峰时段',
                        '根据课程人数和教室容量进行精确匹配，避免大教室小班级现象',
                        '开放教室实时预约系统，提高临时使用效率'
                    ],
                    'expected_improvement': {
                        'usage_rate': 85,
                        'vacancy_reduction': 40,
                        'congestion_reduction': 30
                    },
                    'implementation_cost': 'medium',
                    'timeframe': '1-2个学期'
                }
            }
        elif resource_type == 'digital':
            # 数字资源优化
            result = {
                'summary': '数字教学资源利用率可提升25%，通过内容优化和界面改进',
                'current_status': {
                    'usage_rate': 65,
                    'user_satisfaction': 75,
                    'resource_coverage': 80
                },
                'optimization_plan': {
                    'steps': [
                        '基于学生行为数据重新组织资源结构，突出高频使用内容',
                        '优化移动端界面，提升用户体验',
                        '增加互动式内容，提高学习参与度',
                        '实施个性化推荐系统，为学生推送最相关资源'
                    ],
                    'expected_improvement': {
                        'usage_rate': 85,
                        'user_satisfaction': 90,
                        'learning_efficiency': 20
                    },
                    'implementation_cost': 'medium to high',
                    'timeframe': '3-6个月'
                }
            }
        elif resource_type == 'teacher':
            # 教师资源优化
            result = {
                'summary': '教师资源分配可优化15%，通过专业匹配和负载均衡',
                'current_status': {
                    'workload_balance': 65,
                    'specialty_match': 75,
                    'teacher_satisfaction': 70
                },
                'optimization_plan': {
                    'steps': [
                        '基于专业背景和教学评价重新分配课程',
                        '平衡教师工作负载，避免部分教师过度负担',
                        '引入"教学团队"模式，促进教师间协作和资源共享',
                        '建立教师培训和发展计划，提升整体教学能力'
                    ],
                    'expected_improvement': {
                        'workload_balance': 85,
                        'specialty_match': 90,
                        'teacher_satisfaction': 85
                    },
                    'implementation_cost': 'low',
                    'timeframe': '1个学期'
                }
            }
        else:
            # 未知资源类型
            return JsonResponse({
                'status': 'error',
                'message': f'未支持的资源类型: {resource_type}',
                'supported_types': ['classroom', 'digital', 'teacher']
            }, status=400)
        
        # 根据学院ID定制方案
        if college_id:
            # 实际应用中，这里应该根据学院特点定制方案
            result['college_specific'] = True
        
        # 根据优化目标调整方案侧重点
        if optimization_target == 'efficiency':
            result['focus'] = '效率提升'
        elif optimization_target == 'quality':
            result['focus'] = '质量提升'
        elif optimization_target == 'cost':
            result['focus'] = '成本控制'
        
        # 返回优化方案
        return JsonResponse({
            'status': 'success',
            'message': '生成资源优化方案成功',
            'data': result
        })
            
    except json.JSONDecodeError:
        logger.error("请求体JSON解析错误")
        return JsonResponse({
            'status': 'error',
            'message': '请求体格式错误，应为JSON格式'
        }, status=400)
    except Exception as e:
        logger.exception(f"生成资源优化方案出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '生成资源优化方案失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 异常检测API
@csrf_exempt
@require_http_methods(["GET"])
def ai_anomaly_detection(request):
    """
    获取教学数据异常检测结果
    @param request: HTTP请求
    @return: JSON 异常检测结果
    """
    try:
        # 获取查询参数
        time_range = request.GET.get('timeRange', 'semester')
        college_id = request.GET.get('collegeId')
        
        logger.info(f"获取异常检测数据: timeRange={time_range}, collegeId={college_id}")
        
        # 异常模式模拟数据
        anomalies = [
            {
                "level": "high",
                "title": "学生出勤率异常下降",
                "description": "工学院自动化专业2023级近两周出勤率下降15%，可能影响期末考试成绩。",
                "data": {
                    "current": 75,
                    "previous": 90,
                    "change": -15
                }
            },
            {
                "level": "medium",
                "title": "资源使用异常",
                "description": "经济学院金融学专业教学资源下载量较上月下降30%，建议排查资源质量。",
                "data": {
                    "current": 320,
                    "previous": 457,
                    "change": -30
                }
            },
            {
                "level": "low",
                "title": "成绩分布异常",
                "description": "计算机科学学院软件工程《数据库系统》课程成绩分布呈双峰状态，或存在教学不均衡现象。",
                "data": {
                    "distribution": [5, 8, 12, 15, 20, 18, 10, 22, 25, 15],
                    "expected": "normal"
                }
            }
        ]
        
        # 根据时间范围添加不同的异常
        if time_range == 'week':
            anomalies.append({
                "level": "high",
                "title": "在线作业完成率急剧下降",
                "description": "过去一周，工学院大多数专业的在线作业完成率下降超过20%，疑似系统故障或期末压力导致。",
                "data": {
                    "current": 65,
                    "previous": 85,
                    "change": -20
                }
            })
        elif time_range == 'month':
            anomalies.append({
                "level": "medium",
                "title": "教师线上答疑活跃度降低",
                "description": "过去一个月，全校教师的线上答疑平台活跃度平均下降25%，建议排查原因或提供使用激励。",
                "data": {
                    "current": 45,
                    "previous": 60,
                    "change": -25
                }
            })
        
        # 如果指定了学院ID，过滤相关异常
        if college_id:
            try:
                college_id = int(college_id)
                # 这里应该实现根据学院ID筛选异常的逻辑
                # 为简化示例，这里仅返回前两个异常
                anomalies = anomalies[:2]
            except ValueError:
                return JsonResponse({
                    'status': 'error',
                    'message': '学院ID必须是整数'
                }, status=400)
        
        # 返回异常检测结果
        return JsonResponse({
            'status': 'success',
            'message': '获取异常检测数据成功',
            'data': anomalies
        })
            
    except Exception as e:
        logger.exception(f"获取异常检测数据出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取异常检测数据失败',
            'error': str(e)
        }, status=500)

# AI决策系统相关接口 - 预测分析API
@csrf_exempt
@require_http_methods(["POST"])
def ai_prediction(request, prediction_type):
    """
    生成教学预测分析
    @param request: HTTP请求
    @param prediction_type: 预测类型(resources/performance/enrollment)
    @return: JSON 预测结果
    """
    try:
        # 解析请求体
        data = json.loads(request.body)
        time_range = data.get('timeRange', 'semester')
        college_id = data.get('collegeId')
        
        logger.info(f"生成预测分析: type={prediction_type}, timeRange={time_range}, collegeId={college_id}")
        
        # 验证预测类型
        valid_types = ['resources', 'performance', 'enrollment']
        if prediction_type not in valid_types:
            return JsonResponse({
                'status': 'error',
                'message': f'未支持的预测类型: {prediction_type}',
                'supported_types': valid_types
            }, status=400)
        
        # 根据预测类型生成不同的预测结果
        if prediction_type == 'resources':
            # 教学资源需求预测
            result = {
                'title': '未来3个月教学资源需求预测',
                'xAxis': ['5月', '6月', '7月'],
                'legend': ['教材', '视频资源', '习题资源', '实验资源'],
                'series': [
                    {
                        'name': '教材',
                        'type': 'bar',
                        'data': [320, 350, 290],
                        'stack': 'total',
                        'emphasis': { 'focus': 'series' }
                    },
                    {
                        'name': '视频资源',
                        'type': 'bar',
                        'data': [420, 450, 500],
                        'stack': 'total',
                        'emphasis': { 'focus': 'series' }
                    },
                    {
                        'name': '习题资源',
                        'type': 'bar',
                        'data': [250, 300, 270],
                        'stack': 'total',
                        'emphasis': { 'focus': 'series' }
                    },
                    {
                        'name': '实验资源',
                        'type': 'bar',
                        'data': [190, 210, 230],
                        'stack': 'total',
                        'emphasis': { 'focus': 'series' }
                    }
                ]
            }
        elif prediction_type == 'performance':
            # 学业表现预测
            result = {
                'title': '学业表现预测',
                'xAxis': ['5月', '6月', '7月'],
                'legend': ['出勤率', '作业完成率', '考试通过率'],
                'series': [
                    {
                        'name': '出勤率',
                        'type': 'line',
                        'data': [85, 87, 82]
                    },
                    {
                        'name': '作业完成率',
                        'type': 'line',
                        'data': [78, 80, 75]
                    },
                    {
                        'name': '考试通过率',
                        'type': 'line',
                        'data': [90, 88, 91]
                    }
                ]
            }
        else:  # enrollment
            # 招生趋势预测
            result = {
                'title': '招生趋势预测',
                'xAxis': ['2024秋季', '2025春季', '2025秋季'],
                'legend': ['工学院', '理学院', '经济学院', '文学院'],
                'series': [
                    {
                        'name': '工学院',
                        'type': 'line',
                        'data': [350, 420, 380]
                    },
                    {
                        'name': '理学院',
                        'type': 'line',
                        'data': [280, 310, 290]
                    },
                    {
                        'name': '经济学院',
                        'type': 'line',
                        'data': [320, 350, 330]
                    },
                    {
                        'name': '文学院',
                        'type': 'line',
                        'data': [250, 280, 270]
                    }
                ]
            }
        
        # 如果指定了学院ID，定制预测结果
        if college_id:
            try:
                college_id = int(college_id)
                # 这里应该实现根据学院ID定制预测的逻辑
                # 为简化示例，这里仅在返回结果中添加学院特定标记
                result['college_specific'] = True
                result['college_id'] = college_id
            except ValueError:
                return JsonResponse({
                    'status': 'error',
                    'message': '学院ID必须是整数'
                }, status=400)
        
        # 返回预测结果
        return JsonResponse({
            'status': 'success',
            'message': '生成预测数据成功',
            'data': result
        })
            
    except json.JSONDecodeError:
        logger.error("请求体JSON解析错误")
        return JsonResponse({
            'status': 'error',
            'message': '请求体格式错误，应为JSON格式'
        }, status=400)
    except Exception as e:
        logger.exception(f"生成预测数据出错: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '生成预测数据失败',
            'error': str(e)
        }, status=500)

# 教师发展支持系统相关接口
@csrf_exempt
@require_http_methods(["GET"])
def teacher_list(request):
    """
    获取教师列表
    @description 返回分页的教师列表数据，支持按学院、职称等筛选
    @param request: HTTP请求
    @return: JsonResponse 教师列表数据
    """
    try:
        # 获取查询参数
        college_id = request.GET.get('college_id', '')
        title = request.GET.get('title', '')
        search_query = request.GET.get('query', '')
        page = int(request.GET.get('page', 1))
        limit = int(request.GET.get('limit', 10))
        
        logger.info(f"获取教师列表: college_id={college_id}, title={title}, query={search_query}, page={page}, limit={limit}")
        
        # 从Teacher模型获取教师数据
        from admin.models import Teacher, College, TeachingStyle
        from django.db.models import Q
        
        query_filter = Q()
        
        if college_id:
            query_filter &= Q(college_id=college_id)
        
        if title:
            query_filter &= Q(title=title)
        
        if search_query:
            query_filter &= (
                Q(teacher_name__icontains=search_query) | 
                Q(teacher_code__icontains=search_query)
            )
        
        # 获取教师列表
        teachers_query = Teacher.objects.filter(query_filter)
        
        # 计算总数
        total = teachers_query.count()
        
        # 分页
        offset = (page - 1) * limit
        paginated_teachers = teachers_query[offset:offset + limit]
        
        # 准备返回数据
        teachers_data = []
        for teacher in paginated_teachers:
            # 获取学院名称
            college_name = "未知学院"
            try:
                college = College.objects.get(id=teacher.college_id)
                college_name = college.name
            except College.DoesNotExist:
                pass
            
            # 获取教学风格数据
            teaching_style = "暂无教学风格数据"
            try:
                style = TeachingStyle.objects.get(teacher_id=teacher.teacher_id)
                teaching_style = style.style_summary
            except TeachingStyle.DoesNotExist:
                pass
            
            # 计算教学年限（如果有入职日期）
            teaching_years = 0
            if teacher.entry_date:
                from datetime import date
                teaching_years = (date.today().year - teacher.entry_date.year)
            
            # 构建教师数据
            teacher_data = {
                "id": teacher.teacher_id,
                "teacher_id": teacher.teacher_code,
                "name": teacher.teacher_name,
                "title": teacher.title,
                "college_id": teacher.college_id,
                "college_name": college_name,
                "teaching_years": teaching_years,
                "research_area": teacher.specialty,
                "teaching_style": teaching_style
            }
            
            teachers_data.append(teacher_data)
        
        # 返回结果
        return JsonResponse({
            'status': 'success',
            'message': '获取教师列表成功',
            'data': {
                'total': total,
                'page': page,
                'limit': limit,
                'teachers': teachers_data
            }
        })
    
    except Exception as e:
        logger.exception(f"获取教师列表失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取教师列表失败',
            'error': str(e)
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def teacher_detail(request, teacher_id):
    """
    获取教师详细信息
    @description 返回指定教师ID的详细信息，包括教学风格、效能分析等
    @param request: HTTP请求
    @param teacher_id: 教师ID
    @return: JsonResponse 教师详细信息
    """
    try:
        logger.info(f"获取教师详情: teacher_id={teacher_id}")
        
        # 从数据库获取教师信息
        from admin.models import Teacher, College, TeachingStyle, TrainingRecommendation
        
        # 尝试按ID查找教师
        try:
            # 先尝试按teacher_id查找
            if str(teacher_id).isdigit():
                teacher = Teacher.objects.get(teacher_id=int(teacher_id))
            else:
                # 如果不是数字，尝试按teacher_code查找
                teacher = Teacher.objects.get(teacher_code=teacher_id)
                
            # 获取学院名称
            college_name = "未知学院"
            try:
                college = College.objects.get(id=teacher.college_id)
                college_name = college.name
            except College.DoesNotExist:
                pass
            
            # 获取教学风格
            teaching_style = "暂无教学风格数据"
            try:
                style = TeachingStyle.objects.get(teacher_id=teacher.teacher_id)
                teaching_style = style.style_summary
            except TeachingStyle.DoesNotExist:
                pass
            
            # 计算教学年限
            teaching_years = 0
            if teacher.entry_date:
                from datetime import date
                teaching_years = (date.today().year - teacher.entry_date.year)
            
            # 构建基本信息
            teacher_info = {
                "id": teacher.teacher_id,
                "teacher_id": teacher.teacher_code,
                "name": teacher.teacher_name,
                "title": teacher.title,
                "college_id": teacher.college_id,
                "college_name": college_name,
                "teaching_years": teaching_years,
                "research_area": teacher.specialty,
                "teaching_style": teaching_style,
                "email": teacher.email if hasattr(teacher, 'email') else "",
                "phone": teacher.phone if hasattr(teacher, 'phone') else ""
            }
            
            # 获取培训推荐
            training_recommendations = []
            trainings = TrainingRecommendation.objects.filter(teacher_id=teacher.teacher_id)
            for training in trainings:
                training_recommendations.append({
                    "id": training.id,
                    "title": training.title,
                    "description": training.description,
                    "match": training.match_score,
                    "duration": training.duration,
                    "start_date": training.created_at.strftime("%Y-%m-%d") if training.created_at else "",
                    "location": "在线课程" if "在线" in training.description else "教师发展中心"
                })
            
            # 模拟教学效能数据 (这部分可以在后续从数据库中获取)
            effectiveness_data = {
                "ratings": [4.2, 4.3, 4.5, 4.4, 4.7],  # 最近5个学期的评分
                "participation": [85, 87, 90, 92, 95],  # 学生参与度百分比
                "completion": [78, 80, 82, 85, 88],     # 课程完成率百分比
                "satisfaction": [4.0, 4.2, 4.3, 4.5, 4.6], # 学生满意度评分
                "analysis": "该教师教学效能整体呈上升趋势，特别是在课堂互动和学生参与度方面表现突出。建议改进：可以进一步优化课程内容组织，增强知识点间的关联性，提高学生的整体理解。"
            }
            
            # 将所有数据组合到一起
            teacher_info.update({
                "effectiveness_data": effectiveness_data,
                "training_recommendations": training_recommendations
            })
            
            return JsonResponse({
                'status': 'success',
                'message': '获取教师详情成功',
                'data': teacher_info
            })
            
        except Teacher.DoesNotExist:
            return JsonResponse({
                'status': 'error',
                'message': f'未找到ID为{teacher_id}的教师',
                'error': 'Teacher not found'
            }, status=404)
        
    except Exception as e:
        logger.exception(f"获取教师详情失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': '获取教师详情失败',
            'error': str(e)
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def teacher_effectiveness(request, teacher_id):
    """
    获取教师教学效能分析数据
    @param request: 请求对象
    @param teacher_id: 教师ID
    @return: JSON响应
    """
    try:
        # 这里应该从数据库获取教师教学效能数据
        # 由于可能没有真实数据，我们使用模拟数据
        
        # 教学效能趋势数据
        effectiveness_trend = {
            'categories': ['2023-01', '2023-02', '2023-03', '2023-04', '2023-05', '2023-06'],
            'series': [
                {
                    'name': '学生参与度',
                    'data': [85, 87, 84, 90, 92, 94]
                },
                {
                    'name': '课堂互动',
                    'data': [78, 80, 83, 85, 88, 90]
                },
                {
                    'name': '教学内容质量',
                    'data': [82, 84, 86, 85, 87, 89]
                },
                {
                    'name': '学生理解度',
                    'data': [75, 78, 80, 83, 85, 88]
                }
            ]
        }
        
        # AI分析报告
        ai_analysis = {
            'summary': '该教师的教学效能总体呈上升趋势，特别是在学生参与度和课堂互动方面有显著提高。',
            'strengths': [
                '课堂互动技巧娴熟，善于调动学生积极性',
                '教学内容组织合理，讲解清晰',
                '关注学生个体差异，因材施教'
            ],
            'improvements': [
                '可进一步优化课程内容组织，增强知识点间的关联性',
                '适当增加实践环节，提高学生动手能力',
                '加强学习效果的反馈与评估环节'
            ],
            'recommendations': [
                '建议参加"混合式教学设计与实践"培训',
                '可尝试引入更多合作学习策略',
                '建议增加课前预习材料的分享'
            ]
        }
        
        # 结合数据
        data = {
            'effectiveness_trend': effectiveness_trend,
            'ai_analysis': ai_analysis
        }
        
        return JsonResponse({
            'status': 'success',
            'message': '获取教师教学效能分析成功',
            'data': data
        })
    except Exception as e:
        logger.error(f"获取教师教学效能分析失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取教师教学效能分析失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def teacher_training_recommendations(request, teacher_id):
    """
    获取教师培训推荐
    @param request: 请求对象
    @param teacher_id: 教师ID
    @return: JSON响应
    """
    try:
        # 这里应该根据教师ID获取匹配的培训推荐
        # 由于可能没有真实数据，我们使用模拟数据
        
        trainings = [
            {
                'id': 'tr001',
                'title': '混合式教学设计与实践',
                'description': '学习如何设计和实施有效的混合式教学模式，整合线上线下资源。',
                'match': 95,
                'duration': '20小时',
                'organizer': '教师发展中心',
                'start_date': '2025-06-10',
                'format': '线上线下结合',
                'benefits': ['提升混合式教学技能', '获取实用教学工具', '与优秀教师交流'],
                'tags': ['混合式教学', '教学设计', '技术整合']
            },
            {
                'id': 'tr002',
                'title': '教育数据分析与应用',
                'description': '学习如何利用教育数据分析学生学习行为和效果，改进教学策略。',
                'match': 87,
                'duration': '15小时',
                'organizer': '教育技术中心',
                'start_date': '2025-06-20',
                'format': '线上',
                'benefits': ['掌握数据分析方法', '提升教学决策能力', '优化学生学习体验'],
                'tags': ['数据分析', '教学评估', '决策优化']
            },
            {
                'id': 'tr003',
                'title': '创新教学方法工作坊',
                'description': '探索项目式学习、翻转课堂等创新教学方法，提升教学互动性。',
                'match': 82,
                'duration': '12小时',
                'organizer': '教学创新研究所',
                'start_date': '2025-07-05',
                'format': '线下',
                'benefits': ['掌握创新教学方法', '提高课堂互动性', '激发学生学习动机'],
                'tags': ['创新教学', '项目式学习', '翻转课堂']
            },
            {
                'id': 'tr004',
                'title': '学科教学深度研修',
                'description': '深入研究学科核心概念和难点，探讨有效的教学策略。',
                'match': 78,
                'duration': '25小时',
                'organizer': '学科教学研究中心',
                'start_date': '2025-07-15',
                'format': '线下',
                'benefits': ['深化学科理解', '掌握难点教学策略', '提升教学效果'],
                'tags': ['学科教学', '教学重难点', '教学策略']
            }
        ]
        
        return JsonResponse({
            'status': 'success',
            'message': '获取教师培训推荐成功',
            'data': trainings
        })
    except Exception as e:
        logger.error(f"获取教师培训推荐失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取教师培训推荐失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def teacher_collaboration_recommendations(request, teacher_id):
    """
    获取教师协作推荐
    @param request: 请求对象
    @param teacher_id: 教师ID
    @return: JSON响应
    """
    try:
        # 这里应该根据教师ID获取匹配的协作教师推荐
        # 由于可能没有真实数据，我们使用模拟数据
        
        # 协作网络数据
        network_data = {
            'nodes': [
                {'id': 'teacher1', 'name': '当前教师', 'value': 50, 'category': 0},
                {'id': 'teacher2', 'name': '赵教授', 'value': 30, 'category': 1},
                {'id': 'teacher3', 'name': '钱副教授', 'value': 25, 'category': 2},
                {'id': 'teacher4', 'name': '孙讲师', 'value': 20, 'category': 1},
                {'id': 'teacher5', 'name': '李教授', 'value': 15, 'category': 2},
                {'id': 'teacher6', 'name': '周副教授', 'value': 10, 'category': 3}
            ],
            'links': [
                {'source': 'teacher1', 'target': 'teacher2', 'value': 92},
                {'source': 'teacher1', 'target': 'teacher3', 'value': 88},
                {'source': 'teacher1', 'target': 'teacher4', 'value': 85},
                {'source': 'teacher1', 'target': 'teacher5', 'value': 70},
                {'source': 'teacher1', 'target': 'teacher6', 'value': 65},
                {'source': 'teacher2', 'target': 'teacher3', 'value': 60},
                {'source': 'teacher2', 'target': 'teacher5', 'value': 55},
                {'source': 'teacher3', 'target': 'teacher4', 'value': 50},
                {'source': 'teacher4', 'target': 'teacher6', 'value': 45}
            ],
            'categories': [
                {'name': '当前教师'},
                {'name': '计算机学院'},
                {'name': '工学院'},
                {'name': '经济学院'}
            ]
        }
        
        # 推荐协作教师
        collaborators = [
            {
                'id': 'teacher2',
                'name': '赵教授',
                'title': '教授',
                'college': '计算机科学与技术学院',
                'match': 92,
                'reason': '教学风格互补，可合作开发跨学科课程',
                'research_areas': ['人工智能', '数据科学', '计算机教育'],
                'expertise': ['机器学习', '深度学习', '教学创新'],
                'contact': 'zhao@example.edu'
            },
            {
                'id': 'teacher3',
                'name': '钱副教授',
                'title': '副教授',
                'college': '工学院',
                'match': 88,
                'reason': '研究方向相近，可共同指导学生项目',
                'research_areas': ['智能制造', '工程教育', '人机交互'],
                'expertise': ['智能系统', '项目式教学', '学生评估'],
                'contact': 'qian@example.edu'
            },
            {
                'id': 'teacher4',
                'name': '孙讲师',
                'title': '讲师',
                'college': '计算机科学与技术学院',
                'match': 85,
                'reason': '教学经验与技术专长互补，可协作教学',
                'research_areas': ['软件工程', '教育技术', '程序设计教学'],
                'expertise': ['编程教学', '课程设计', '在线教育'],
                'contact': 'sun@example.edu'
            }
        ]
        
        # 合作项目建议
        project_suggestions = [
            {
                'title': '跨学科AI教学案例库建设',
                'description': '整合计算机科学与其他学科的AI应用案例，建立综合教学资源库',
                'participants': ['赵教授', '钱副教授'],
                'estimated_duration': '6个月',
                'expected_outcomes': ['AI教学案例集', '跨学科教学指南', '学生项目模板']
            },
            {
                'title': '混合式教学模式研究与实践',
                'description': '探索线上线下结合的混合式教学模式，提高教学效果',
                'participants': ['孙讲师'],
                'estimated_duration': '3个月',
                'expected_outcomes': ['混合式教学模型', '教学实施方案', '教学效果评估报告']
            }
        ]
        
        # 结合数据
        data = {
            'network_data': network_data,
            'collaborators': collaborators,
            'project_suggestions': project_suggestions
        }
        
        return JsonResponse({
            'status': 'success',
            'message': '获取教师协作推荐成功',
            'data': data
        })
    except Exception as e:
        logger.error(f"获取教师协作推荐失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取教师协作推荐失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def teacher_resource_recommendations(request):
    """
    获取教师资源推荐
    @param request: 请求对象
    @return: JSON响应
    """
    try:
        # 从请求参数中获取教师ID和资源类别
        teacher_id = request.GET.get('teacherId', '')
        category = request.GET.get('category', '')
        
        # 这里应该根据教师ID和类别获取匹配的资源推荐
        # 由于可能没有真实数据，我们使用模拟数据
        
        resources = [
            {
                'id': 'res001',
                'title': '高效课堂互动技巧',
                'description': '介绍10种提高课堂互动性和学生参与度的实用技巧。',
                'type': 'video',
                'category': '教学方法',
                'views': 1245,
                'duration': '45分钟',
                'author': '教学创新中心',
                'rating': 4.8,
                'tags': ['课堂互动', '学生参与', '教学技巧'],
                'url': 'https://example.com/resources/interactive-teaching'
            },
            {
                'id': 'res002',
                'title': '数据结构课程教案集',
                'description': '包含完整的数据结构课程教案、习题和教学案例。',
                'type': 'document',
                'category': '课程资源',
                'views': 856,
                'pages': 120,
                'author': '计算机教育研究组',
                'rating': 4.6,
                'tags': ['数据结构', '教案', '教学资源'],
                'url': 'https://example.com/resources/data-structure-teaching'
            },
            {
                'id': 'res003',
                'title': 'AI辅助教学实践',
                'description': '探索如何将人工智能技术应用于教学过程的在线课程。',
                'type': 'course',
                'category': '教育技术',
                'views': 672,
                'duration': '10小时',
                'author': '教育技术中心',
                'rating': 4.7,
                'tags': ['AI教学', '教育技术', '创新教学'],
                'url': 'https://example.com/resources/ai-teaching'
            },
            {
                'id': 'res004',
                'title': '项目式学习案例库',
                'description': '收集了50个适合计算机专业的项目式学习案例。',
                'type': 'document',
                'category': '教学资源',
                'views': 543,
                'pages': 85,
                'author': '教学研究中心',
                'rating': 4.5,
                'tags': ['项目式学习', '案例教学', '实践教学'],
                'url': 'https://example.com/resources/project-based-learning'
            }
        ]
        
        # 如果指定了类别，进行过滤
        if category:
            resources = [res for res in resources if res['category'] == category]
        
        return JsonResponse({
            'status': 'success',
            'message': '获取教师资源推荐成功',
            'data': resources
        })
    except Exception as e:
        logger.error(f"获取教师资源推荐失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'获取教师资源推荐失败: {str(e)}'
        }, status=500)

@csrf_exempt
@require_http_methods(["GET"])
def teacher_development_system(request):
    """
    教师发展系统视图 (占位符)
    @route GET /api/admin/teacher-development/
    @description 这是一个占位符视图，待后续实现。
    @created 2024-07-27
    """
    # TODO: 实现教师发展系统的具体逻辑
    return JsonResponse({
        'status': 'info',
        'message': '教师发展系统接口暂未实现。',
        'data': {}
    })

def create_class_analysis_tables(cursor):
    """创建班级学习分析临时表（如果不存在）"""
    try:
        # 检查是否存在class_learning_analysis表
        cursor.execute("""
            SELECT COUNT(*) FROM information_schema.tables 
            WHERE table_schema = DATABASE() 
            AND table_name = 'class_learning_analysis'
        """)
        if cursor.fetchone()[0] == 0:
            # 创建class_learning_analysis表
            cursor.execute("""
                CREATE TABLE IF NOT EXISTS class_learning_analysis (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    class_id INT NOT NULL,
                    analysis_type VARCHAR(50) NOT NULL,
                    stats JSON,
                    grade_distribution JSON,
                    knowledge_mastery JSON,
                    learning_progress JSON,
                    homework_status JSON,
                    recommendations JSON,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                    INDEX idx_class_analysis (class_id, analysis_type)
                )
            """)
            print("创建了class_learning_analysis表")
        return True
    except Exception as e:
        print(f"检查或创建表时出错: {e}")
        return False

def generate_knowledge_mastery_data(cursor, class_id):
    """生成知识点掌握情况数据"""
    try:
        # 检查数据库中是否有预定义的知识点
        cursor.execute("""
            SELECT knowledge_mastery 
            FROM class_learning_analysis 
            WHERE class_id = %s AND analysis_type = 'learning'
        """, [class_id])
        
        result = cursor.fetchone()
        if result and result[0]:
            # 使用已有数据
            return json.loads(result[0])
    except Exception as e:
        # 记录错误并继续使用随机数据
        print(f"获取知识点掌握情况出错: {e}")
        
    # 随机生成知识点掌握数据
    knowledge_areas = ["数据结构", "算法分析", "编程基础", "数据库", "计算机网络"]
    knowledge_values = []
    for _ in range(len(knowledge_areas)):
        knowledge_values.append(random.randint(65, 95))
    
    return {
        'areas': knowledge_areas,
        'values': knowledge_values
    }

def generate_learning_progress_data(cursor, class_id):
    """生成学习进度数据"""
    try:
        # 检查数据库中是否有预定义的学习进度
        cursor.execute("""
            SELECT learning_progress 
            FROM class_learning_analysis 
            WHERE class_id = %s AND analysis_type = 'learning'
        """, [class_id])
        
        result = cursor.fetchone()
        if result and result[0]:
            # 使用已有数据
            return json.loads(result[0])
    except Exception as e:
        # 记录错误并继续使用随机数据
        print(f"获取学习进度出错: {e}")
    
    # 随机生成学习进度数据
    weeks = ["第1周", "第2周", "第3周", "第4周", "第5周", "第6周"]
    values = []
    current_value = random.randint(60, 70)
    for _ in range(len(weeks)):
        values.append(current_value)
        current_value += random.randint(3, 8)
        if current_value > 98:
            current_value = 98
    
    return {
        'weeks': weeks,
        'values': values
    }

def generate_homework_status_data(cursor, class_id):
    """生成作业完成情况数据"""
    try:
        # 检查数据库中是否有预定义的作业完成情况
        cursor.execute("""
            SELECT homework_status 
            FROM class_learning_analysis 
            WHERE class_id = %s AND analysis_type = 'learning'
        """, [class_id])
        
        result = cursor.fetchone()
        if result and result[0]:
            # 使用已有数据
            return json.loads(result[0])
    except Exception as e:
        # 记录错误并继续使用随机数据
        print(f"获取作业完成情况出错: {e}")
    
    # 随机生成作业完成情况数据
    return {
        'ontime': random.randint(60, 80),
        'late': random.randint(10, 25),
        'incomplete': random.randint(3, 15)
    }

def generate_class_recommendations(avg_score, pass_rate, attendance_rate, 
                                 homework_completion_rate, knowledge_levels, knowledge_areas):
    """生成班级学习建议"""
    recommendations = []
    
    # 示例：如果平均分低于70，则建议加强基础知识教学
    if avg_score < 70:
        recommendations.append({
            "type": "教学策略",
            "content": "当前班级平均分较低，建议教师加强基础知识点的讲解和练习，确保学生掌握基本概念。",
            "level": "重要"
        })

    # 示例：如果及格率低于80%，则建议关注学习困难学生
    if pass_rate < 0.8:
        recommendations.append({
            "type": "学生辅导",
            "content": "班级及格率有待提高，建议对学习有困难的学生进行个性化辅导，帮助他们跟上进度。",
            "level": "重要"
        })
    
    # 示例：根据知识点掌握情况生成建议
    if knowledge_levels:
        weak_knowledge_points = [kp for kp, level in knowledge_levels.items() if level == '薄弱']
        if weak_knowledge_points:
            recommendations.append({
                "type": "知识点强化",
                "content": f"学生在以下知识点上掌握较为薄弱：{', '.join(weak_knowledge_points)}。建议针对这些知识点进行强化练习和复习。",
                "level": "一般"
            })

    if not recommendations:
        recommendations.append({
            "type": "整体情况",
            "content": "班级整体学习情况良好，请继续保持。",
            "level": "一般"
        })
        
    return recommendations

# 新增的装饰器工厂
from functools import wraps

def require_role(allowed_roles):
    """
    Decorator to check if the user has one of the allowed roles.
    Assumes token is passed in 'Authorization: Bearer <token>' header.
    """
    def decorator(view_func):
        @wraps(view_func)
        def _wrapped_view(request, *args, **kwargs):
            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
            if not auth_header.startswith('Bearer '):
                logger.warning("API permission check: Bearer token missing.")
                return JsonResponse({
                    'status': 'error',
                    'message': '未提供有效的令牌 (请求头 Authorization 格式应为 Bearer <token>)'
                }, status=401)

            token_str = auth_header.split(' ')[1]
            payload = validate_token(token_str) # Use the existing validator

            if not payload:
                logger.warning(f"API permission check: Invalid or expired token provided: {token_str[:20]}...")
                return JsonResponse({
                    'status': 'error',
                    'message': '令牌无效或已过期'
                }, status=401)

            user_role = payload.get('role')
            user_id = payload.get('user_id') # For logging
            username = payload.get('username') # For logging

            if not user_role or user_role not in allowed_roles:
                logger.warning(f"API permission check: User {username}/{user_id} (Role: {user_role}) "
                               f"attempted to access restricted resource. Allowed roles: {allowed_roles}.")
                return JsonResponse({
                    'status': 'error',
                    'message': '权限不足，您的角色没有权限访问此资源。'
                }, status=403)
            
            # Add user payload to request for easier access in view if needed
            request.user_payload = payload 
            logger.info(f"API permission check: User {username}/{user_id} (Role: {user_role}) granted access. Allowed roles: {allowed_roles}.")
            return view_func(request, *args, **kwargs)
        return _wrapped_view
    return decorator


